From 1320653f24c1a96059f025806b9a131519de5256 Mon Sep 17 00:00:00 2001 From: Luke Pulverenti Date: Wed, 26 Oct 2016 15:29:56 -0400 Subject: [PATCH] more steps to make provider project portable --- BDInfo/BDInfo.csproj | 77 + BDInfo/BDInfoSettings.cs | 105 + BDInfo/BDROM.cs | 442 + BDInfo/BitVector32.cs | 314 + BDInfo/LanguageCodes.cs | 493 + BDInfo/Properties/AssemblyInfo.cs | 29 + BDInfo/ReadMe.txt | 5 + BDInfo/TSCodecAC3.cs | 309 + BDInfo/TSCodecAVC.cs | 148 + BDInfo/TSCodecDTS.cs | 159 + BDInfo/TSCodecDTSHD.cs | 246 + BDInfo/TSCodecLPCM.cs | 123 + BDInfo/TSCodecMPEG2.cs | 208 + BDInfo/TSCodecMVC.cs | 36 + BDInfo/TSCodecTrueHD.cs | 186 + BDInfo/TSCodecVC1.cs | 131 + BDInfo/TSInterleavedFile.cs | 37 + BDInfo/TSPlaylistFile.cs | 1284 ++ BDInfo/TSStream.cs | 801 + BDInfo/TSStreamBuffer.cs | 142 + BDInfo/TSStreamClip.cs | 113 + BDInfo/TSStreamClipFile.cs | 247 + BDInfo/TSStreamFile.cs | 1549 ++ BDInfo/project.json | 16 + BDInfo/project.lock.json | 18472 ++++++++++++++++ DvdLib/BigEndianBinaryReader.cs | 33 + DvdLib/DvdLib.csproj | 76 + DvdLib/DvdLib.nuget.targets | 6 + DvdLib/Ifo/AudioAttributes.cs | 41 + DvdLib/Ifo/Cell.cs | 24 + DvdLib/Ifo/CellPlaybackInfo.cs | 54 + DvdLib/Ifo/CellPositionInfo.cs | 21 + DvdLib/Ifo/Chapter.cs | 21 + DvdLib/Ifo/Dvd.cs | 161 + DvdLib/Ifo/DvdTime.cs | 34 + DvdLib/Ifo/PgcCommandTable.cs | 20 + DvdLib/Ifo/Program.cs | 17 + DvdLib/Ifo/ProgramChain.cs | 117 + DvdLib/Ifo/Title.cs | 64 + DvdLib/Ifo/UserOperation.cs | 38 + DvdLib/Ifo/VideoAttributes.cs | 51 + DvdLib/Properties/AssemblyInfo.cs | 29 + DvdLib/project.json | 16 + DvdLib/project.lock.json | 3965 ++++ .../MediaBrowser.MediaEncoding.csproj | 15 +- MediaBrowser.MediaEncoding/packages.config | 4 - .../MediaBrowser.Providers.csproj | 17 +- .../MediaInfo/FFProbeVideoInfo.cs | 2 +- MediaBrowser.Providers/packages.config | 4 - MediaBrowser.sln | 64 + .../MediaBrowser.BdInfo.1.0.1.nupkg | Bin 49484 -> 0 bytes .../lib/portable-net46+win10/BDInfo.dll | Bin 87552 -> 0 bytes .../lib/portable-net46+win10/DvdLib.dll | Bin 17920 -> 0 bytes 53 files changed, 30534 insertions(+), 32 deletions(-) create mode 100644 BDInfo/BDInfo.csproj create mode 100644 BDInfo/BDInfoSettings.cs create mode 100644 BDInfo/BDROM.cs create mode 100644 BDInfo/BitVector32.cs create mode 100644 BDInfo/LanguageCodes.cs create mode 100644 BDInfo/Properties/AssemblyInfo.cs create mode 100644 BDInfo/ReadMe.txt create mode 100644 BDInfo/TSCodecAC3.cs create mode 100644 BDInfo/TSCodecAVC.cs create mode 100644 BDInfo/TSCodecDTS.cs create mode 100644 BDInfo/TSCodecDTSHD.cs create mode 100644 BDInfo/TSCodecLPCM.cs create mode 100644 BDInfo/TSCodecMPEG2.cs create mode 100644 BDInfo/TSCodecMVC.cs create mode 100644 BDInfo/TSCodecTrueHD.cs create mode 100644 BDInfo/TSCodecVC1.cs create mode 100644 BDInfo/TSInterleavedFile.cs create mode 100644 BDInfo/TSPlaylistFile.cs create mode 100644 BDInfo/TSStream.cs create mode 100644 BDInfo/TSStreamBuffer.cs create mode 100644 BDInfo/TSStreamClip.cs create mode 100644 BDInfo/TSStreamClipFile.cs create mode 100644 BDInfo/TSStreamFile.cs create mode 100644 BDInfo/project.json create mode 100644 BDInfo/project.lock.json create mode 100644 DvdLib/BigEndianBinaryReader.cs create mode 100644 DvdLib/DvdLib.csproj create mode 100644 DvdLib/DvdLib.nuget.targets create mode 100644 DvdLib/Ifo/AudioAttributes.cs create mode 100644 DvdLib/Ifo/Cell.cs create mode 100644 DvdLib/Ifo/CellPlaybackInfo.cs create mode 100644 DvdLib/Ifo/CellPositionInfo.cs create mode 100644 DvdLib/Ifo/Chapter.cs create mode 100644 DvdLib/Ifo/Dvd.cs create mode 100644 DvdLib/Ifo/DvdTime.cs create mode 100644 DvdLib/Ifo/PgcCommandTable.cs create mode 100644 DvdLib/Ifo/Program.cs create mode 100644 DvdLib/Ifo/ProgramChain.cs create mode 100644 DvdLib/Ifo/Title.cs create mode 100644 DvdLib/Ifo/UserOperation.cs create mode 100644 DvdLib/Ifo/VideoAttributes.cs create mode 100644 DvdLib/Properties/AssemblyInfo.cs create mode 100644 DvdLib/project.json create mode 100644 DvdLib/project.lock.json delete mode 100644 MediaBrowser.MediaEncoding/packages.config delete mode 100644 MediaBrowser.Providers/packages.config delete mode 100644 packages/MediaBrowser.BdInfo.1.0.1/MediaBrowser.BdInfo.1.0.1.nupkg delete mode 100644 packages/MediaBrowser.BdInfo.1.0.1/lib/portable-net46+win10/BDInfo.dll delete mode 100644 packages/MediaBrowser.BdInfo.1.0.1/lib/portable-net46+win10/DvdLib.dll diff --git a/BDInfo/BDInfo.csproj b/BDInfo/BDInfo.csproj new file mode 100644 index 0000000000..d07d4ce2b0 --- /dev/null +++ b/BDInfo/BDInfo.csproj @@ -0,0 +1,77 @@ + + + + + 14.0 + Debug + AnyCPU + {88AE38DF-19D7-406F-A6A9-09527719A21E} + Library + Properties + BDInfo + BDInfo + en-US + 512 + {786C830F-07A1-408B-BD7F-6EE04809D6DB};{FAE04EC0-301F-11D3-BF4B-00C04F79EFBC} + + + v5.0 + + + true + full + false + bin\Debug\ + DEBUG;TRACE + prompt + 4 + + + pdbonly + true + bin\Release\ + TRACE + prompt + 4 + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + if $(ConfigurationName) == Release ( +xcopy "$(TargetPath)" "$(SolutionDir)\Nuget\dlls\" /y /d /r /i +) + + + \ No newline at end of file diff --git a/BDInfo/BDInfoSettings.cs b/BDInfo/BDInfoSettings.cs new file mode 100644 index 0000000000..7abb67499f --- /dev/null +++ b/BDInfo/BDInfoSettings.cs @@ -0,0 +1,105 @@ + +namespace BDInfo +{ + class BDInfoSettings + { + public static bool GenerateStreamDiagnostics + { + get + { + return true; + } + } + + public static bool EnableSSIF + { + get + { + return true; + } + } + + public static bool AutosaveReport + { + get + { + return false; + } + } + + public static bool GenerateFrameDataFile + { + get + { + return false; + } + } + + public static bool FilterLoopingPlaylists + { + get + { + return true; + } + } + + public static bool FilterShortPlaylists + { + get + { + return false; + } + } + + public static int FilterShortPlaylistsValue + { + get + { + return 0; + } + } + + public static bool UseImagePrefix + { + get + { + return false; + } + } + + public static string UseImagePrefixValue + { + get + { + return null; + } + } + + /// + /// Setting this to false throws an IComparer error on some discs. + /// + public static bool KeepStreamOrder + { + get + { + return true; + } + } + + public static bool GenerateTextSummary + { + get + { + return false; + } + } + + public static string LastPath + { + get + { + return string.Empty; + } + } + } +} diff --git a/BDInfo/BDROM.cs b/BDInfo/BDROM.cs new file mode 100644 index 0000000000..26d721268c --- /dev/null +++ b/BDInfo/BDROM.cs @@ -0,0 +1,442 @@ +//============================================================================ +// BDInfo - Blu-ray Video and Audio Analysis Tool +// Copyright © 2010 Cinema Squid +// +// This library is free software; you can redistribute it and/or +// modify it under the terms of the GNU Lesser General Public +// License as published by the Free Software Foundation; either +// version 2.1 of the License, or (at your option) any later version. +// +// This library is distributed in the hope that it will be useful, +// but WITHOUT ANY WARRANTY; without even the implied warranty of +// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU +// Lesser General Public License for more details. +// +// You should have received a copy of the GNU Lesser General Public +// License along with this library; if not, write to the Free Software +// Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA +//============================================================================= + +using System; +using System.Collections.Generic; +using System.IO; + +namespace BDInfo +{ + public class BDROM + { + public DirectoryInfo DirectoryRoot = null; + public DirectoryInfo DirectoryBDMV = null; + public DirectoryInfo DirectoryBDJO = null; + public DirectoryInfo DirectoryCLIPINF = null; + public DirectoryInfo DirectoryPLAYLIST = null; + public DirectoryInfo DirectorySNP = null; + public DirectoryInfo DirectorySSIF = null; + public DirectoryInfo DirectorySTREAM = null; + + public string VolumeLabel = null; + public ulong Size = 0; + public bool IsBDPlus = false; + public bool IsBDJava = false; + public bool IsDBOX = false; + public bool IsPSP = false; + public bool Is3D = false; + public bool Is50Hz = false; + + public Dictionary PlaylistFiles = + new Dictionary(); + public Dictionary StreamClipFiles = + new Dictionary(); + public Dictionary StreamFiles = + new Dictionary(); + public Dictionary InterleavedFiles = + new Dictionary(); + + private static List ExcludeDirs = new List { "ANY!", "AACS", "BDSVM", "ANYVM", "SLYVM" }; + + public delegate bool OnStreamClipFileScanError( + TSStreamClipFile streamClipFile, Exception ex); + + public event OnStreamClipFileScanError StreamClipFileScanError; + + public delegate bool OnStreamFileScanError( + TSStreamFile streamClipFile, Exception ex); + + public event OnStreamFileScanError StreamFileScanError; + + public delegate bool OnPlaylistFileScanError( + TSPlaylistFile playlistFile, Exception ex); + + public event OnPlaylistFileScanError PlaylistFileScanError; + + public BDROM( + string path) + { + // + // Locate BDMV directories. + // + + DirectoryBDMV = + GetDirectoryBDMV(path); + + if (DirectoryBDMV == null) + { + throw new Exception("Unable to locate BD structure."); + } + + DirectoryRoot = + DirectoryBDMV.Parent; + DirectoryBDJO = + GetDirectory("BDJO", DirectoryBDMV, 0); + DirectoryCLIPINF = + GetDirectory("CLIPINF", DirectoryBDMV, 0); + DirectoryPLAYLIST = + GetDirectory("PLAYLIST", DirectoryBDMV, 0); + DirectorySNP = + GetDirectory("SNP", DirectoryRoot, 0); + DirectorySTREAM = + GetDirectory("STREAM", DirectoryBDMV, 0); + DirectorySSIF = + GetDirectory("SSIF", DirectorySTREAM, 0); + + if (DirectoryCLIPINF == null + || DirectoryPLAYLIST == null) + { + throw new Exception("Unable to locate BD structure."); + } + + // + // Initialize basic disc properties. + // + + VolumeLabel = GetVolumeLabel(DirectoryRoot); + Size = (ulong)GetDirectorySize(DirectoryRoot); + + if (null != GetDirectory("BDSVM", DirectoryRoot, 0)) + { + IsBDPlus = true; + } + if (null != GetDirectory("SLYVM", DirectoryRoot, 0)) + { + IsBDPlus = true; + } + if (null != GetDirectory("ANYVM", DirectoryRoot, 0)) + { + IsBDPlus = true; + } + + if (DirectoryBDJO != null && + DirectoryBDJO.GetFiles().Length > 0) + { + IsBDJava = true; + } + + if (DirectorySNP != null && + (DirectorySNP.GetFiles("*.mnv").Length > 0 || DirectorySNP.GetFiles("*.MNV").Length > 0)) + { + IsPSP = true; + } + + if (DirectorySSIF != null && + DirectorySSIF.GetFiles().Length > 0) + { + Is3D = true; + } + + if (File.Exists(Path.Combine(DirectoryRoot.FullName, "FilmIndex.xml"))) + { + IsDBOX = true; + } + + // + // Initialize file lists. + // + + if (DirectoryPLAYLIST != null) + { + FileInfo[] files = DirectoryPLAYLIST.GetFiles("*.mpls"); + if (files.Length == 0) + { + files = DirectoryPLAYLIST.GetFiles("*.MPLS"); + } + foreach (FileInfo file in files) + { + PlaylistFiles.Add( + file.Name.ToUpper(), new TSPlaylistFile(this, file)); + } + } + + if (DirectorySTREAM != null) + { + FileInfo[] files = DirectorySTREAM.GetFiles("*.m2ts"); + if (files.Length == 0) + { + files = DirectoryPLAYLIST.GetFiles("*.M2TS"); + } + foreach (FileInfo file in files) + { + StreamFiles.Add( + file.Name.ToUpper(), new TSStreamFile(file)); + } + } + + if (DirectoryCLIPINF != null) + { + FileInfo[] files = DirectoryCLIPINF.GetFiles("*.clpi"); + if (files.Length == 0) + { + files = DirectoryPLAYLIST.GetFiles("*.CLPI"); + } + foreach (FileInfo file in files) + { + StreamClipFiles.Add( + file.Name.ToUpper(), new TSStreamClipFile(file)); + } + } + + if (DirectorySSIF != null) + { + FileInfo[] files = DirectorySSIF.GetFiles("*.ssif"); + if (files.Length == 0) + { + files = DirectorySSIF.GetFiles("*.SSIF"); + } + foreach (FileInfo file in files) + { + InterleavedFiles.Add( + file.Name.ToUpper(), new TSInterleavedFile(file)); + } + } + } + + public void Scan() + { + List errorStreamClipFiles = new List(); + foreach (TSStreamClipFile streamClipFile in StreamClipFiles.Values) + { + try + { + streamClipFile.Scan(); + } + catch (Exception ex) + { + errorStreamClipFiles.Add(streamClipFile); + if (StreamClipFileScanError != null) + { + if (StreamClipFileScanError(streamClipFile, ex)) + { + continue; + } + else + { + break; + } + } + else throw ex; + } + } + + foreach (TSStreamFile streamFile in StreamFiles.Values) + { + string ssifName = Path.GetFileNameWithoutExtension(streamFile.Name) + ".SSIF"; + if (InterleavedFiles.ContainsKey(ssifName)) + { + streamFile.InterleavedFile = InterleavedFiles[ssifName]; + } + } + + TSStreamFile[] streamFiles = new TSStreamFile[StreamFiles.Count]; + StreamFiles.Values.CopyTo(streamFiles, 0); + Array.Sort(streamFiles, CompareStreamFiles); + + List errorPlaylistFiles = new List(); + foreach (TSPlaylistFile playlistFile in PlaylistFiles.Values) + { + try + { + playlistFile.Scan(StreamFiles, StreamClipFiles); + } + catch (Exception ex) + { + errorPlaylistFiles.Add(playlistFile); + if (PlaylistFileScanError != null) + { + if (PlaylistFileScanError(playlistFile, ex)) + { + continue; + } + else + { + break; + } + } + else throw ex; + } + } + + List errorStreamFiles = new List(); + foreach (TSStreamFile streamFile in streamFiles) + { + try + { + List playlists = new List(); + foreach (TSPlaylistFile playlist in PlaylistFiles.Values) + { + foreach (TSStreamClip streamClip in playlist.StreamClips) + { + if (streamClip.Name == streamFile.Name) + { + playlists.Add(playlist); + break; + } + } + } + streamFile.Scan(playlists, false); + } + catch (Exception ex) + { + errorStreamFiles.Add(streamFile); + if (StreamFileScanError != null) + { + if (StreamFileScanError(streamFile, ex)) + { + continue; + } + else + { + break; + } + } + else throw ex; + } + } + + foreach (TSPlaylistFile playlistFile in PlaylistFiles.Values) + { + playlistFile.Initialize(); + if (!Is50Hz) + { + foreach (TSVideoStream videoStream in playlistFile.VideoStreams) + { + if (videoStream.FrameRate == TSFrameRate.FRAMERATE_25 || + videoStream.FrameRate == TSFrameRate.FRAMERATE_50) + { + Is50Hz = true; + } + } + } + } + } + + private DirectoryInfo GetDirectoryBDMV( + string path) + { + DirectoryInfo dir = new DirectoryInfo(path); + + while (dir != null) + { + if (dir.Name == "BDMV") + { + return dir; + } + dir = dir.Parent; + } + + return GetDirectory("BDMV", new DirectoryInfo(path), 0); + } + + private DirectoryInfo GetDirectory( + string name, + DirectoryInfo dir, + int searchDepth) + { + if (dir != null) + { + DirectoryInfo[] children = dir.GetDirectories(); + foreach (DirectoryInfo child in children) + { + if (child.Name == name) + { + return child; + } + } + if (searchDepth > 0) + { + foreach (DirectoryInfo child in children) + { + GetDirectory( + name, child, searchDepth - 1); + } + } + } + return null; + } + + private long GetDirectorySize(DirectoryInfo directoryInfo) + { + long size = 0; + + //if (!ExcludeDirs.Contains(directoryInfo.Name.ToUpper())) // TODO: Keep? + { + FileInfo[] pathFiles = directoryInfo.GetFiles(); + foreach (FileInfo pathFile in pathFiles) + { + if (pathFile.Extension.ToUpper() == ".SSIF") + { + continue; + } + size += pathFile.Length; + } + + DirectoryInfo[] pathChildren = directoryInfo.GetDirectories(); + foreach (DirectoryInfo pathChild in pathChildren) + { + size += GetDirectorySize(pathChild); + } + } + + return size; + } + + private string GetVolumeLabel(DirectoryInfo dir) + { + return dir.Name; + } + + public static int CompareStreamFiles( + TSStreamFile x, + TSStreamFile y) + { + // TODO: Use interleaved file sizes + + if ((x == null || x.FileInfo == null) && (y == null || y.FileInfo == null)) + { + return 0; + } + else if ((x == null || x.FileInfo == null) && (y != null && y.FileInfo != null)) + { + return 1; + } + else if ((x != null || x.FileInfo != null) && (y == null || y.FileInfo == null)) + { + return -1; + } + else + { + if (x.FileInfo.Length > y.FileInfo.Length) + { + return 1; + } + else if (y.FileInfo.Length > x.FileInfo.Length) + { + return -1; + } + else + { + return 0; + } + } + } + + } +} diff --git a/BDInfo/BitVector32.cs b/BDInfo/BitVector32.cs new file mode 100644 index 0000000000..46f15034b3 --- /dev/null +++ b/BDInfo/BitVector32.cs @@ -0,0 +1,314 @@ +using System; +using System.Collections.Generic; +using System.Linq; +using System.Text; +using System.Threading.Tasks; + +namespace BDInfo +{ + using System.Diagnostics; + using System.Text; + using System; + using Microsoft.Win32; + + /// + /// Provides a simple light bit vector with easy integer or Boolean access to + /// a 32 bit storage. + /// + public struct BitVector32 + { + private uint data; + + /// + /// Initializes a new instance of the BitVector32 structure with the specified internal data. + /// + public BitVector32(int data) + { + this.data = (uint)data; + } + + /// + /// Initializes a new instance of the BitVector32 structure with the information in the specified + /// value. + /// + public BitVector32(BitVector32 value) + { + this.data = value.data; + } + + /// + /// Gets or sets a value indicating whether all the specified bits are set. + /// + public bool this[int bit] + { + get + { + return (data & bit) == (uint)bit; + } + set + { + if (value) + { + data |= (uint)bit; + } + else + { + data &= ~(uint)bit; + } + } + } + + /// + /// Gets or sets the value for the specified section. + /// + public int this[Section section] + { + get + { + return (int)((data & (uint)(section.Mask << section.Offset)) >> section.Offset); + } + set + { +#if DEBUG + if ((value & section.Mask) != value) { + Debug.Fail("Value out of bounds on BitVector32 Section Set!"); + } +#endif + value <<= section.Offset; + int offsetMask = (0xFFFF & (int)section.Mask) << section.Offset; + data = (data & ~(uint)offsetMask) | ((uint)value & (uint)offsetMask); + } + } + + /// + /// returns the raw data stored in this bit vector... + /// + public int Data + { + get + { + return (int)data; + } + } + + private static short CountBitsSet(short mask) + { + + // yes, I know there are better algorithms, however, we know the + // bits are always right aligned, with no holes (i.e. always 00000111, + // never 000100011), so this is just fine... + // + short value = 0; + while ((mask & 0x1) != 0) + { + value++; + mask >>= 1; + } + return value; + } + + /// + /// Creates the first mask in a series. + /// + public static int CreateMask() + { + return CreateMask(0); + } + + /// + /// Creates the next mask in a series. + /// + public static int CreateMask(int previous) + { + if (previous == 0) + { + return 1; + } + + if (previous == unchecked((int)0x80000000)) + { + throw new InvalidOperationException("Bit vector full"); + } + + return previous << 1; + } + + /// + /// Given a highValue, creates the mask + /// + private static short CreateMaskFromHighValue(short highValue) + { + short required = 16; + while ((highValue & 0x8000) == 0) + { + required--; + highValue <<= 1; + } + + ushort value = 0; + while (required > 0) + { + required--; + value <<= 1; + value |= 0x1; + } + + return unchecked((short)value); + } + + /// + /// Creates the first section in a series, with the specified maximum value. + /// + public static Section CreateSection(short maxValue) + { + return CreateSectionHelper(maxValue, 0, 0); + } + + /// + /// Creates the next section in a series, with the specified maximum value. + /// + public static Section CreateSection(short maxValue, Section previous) + { + return CreateSectionHelper(maxValue, previous.Mask, previous.Offset); + } + + private static Section CreateSectionHelper(short maxValue, short priorMask, short priorOffset) + { + if (maxValue < 1) + { + throw new ArgumentOutOfRangeException("maxValue"); + } +#if DEBUG + int maskCheck = CreateMaskFromHighValue(maxValue); + int offsetCheck = priorOffset + CountBitsSet(priorMask); + Debug.Assert(maskCheck <= short.MaxValue && offsetCheck < 32, "Overflow on BitVector32"); +#endif + short offset = (short)(priorOffset + CountBitsSet(priorMask)); + if (offset >= 32) + { + throw new InvalidOperationException("Bit vector full"); + } + return new Section(CreateMaskFromHighValue(maxValue), offset); + } + + public override bool Equals(object o) + { + if (!(o is BitVector32)) + { + return false; + } + + return data == ((BitVector32)o).data; + } + + public override int GetHashCode() + { + return base.GetHashCode(); + } + + /// + /// + public static string ToString(BitVector32 value) + { + StringBuilder sb = new StringBuilder(/*"BitVector32{".Length*/12 + /*32 bits*/32 + /*"}".Length"*/1); + sb.Append("BitVector32{"); + int locdata = (int)value.data; + for (int i = 0; i < 32; i++) + { + if ((locdata & 0x80000000) != 0) + { + sb.Append("1"); + } + else + { + sb.Append("0"); + } + locdata <<= 1; + } + sb.Append("}"); + return sb.ToString(); + } + + /// + /// + public override string ToString() + { + return BitVector32.ToString(this); + } + + /// + /// + /// Represents an section of the vector that can contain a integer number. + /// + public struct Section + { + private readonly short mask; + private readonly short offset; + + internal Section(short mask, short offset) + { + this.mask = mask; + this.offset = offset; + } + + public short Mask + { + get + { + return mask; + } + } + + public short Offset + { + get + { + return offset; + } + } + + public override bool Equals(object o) + { + if (o is Section) + return Equals((Section)o); + else + return false; + } + + public bool Equals(Section obj) + { + return obj.mask == mask && obj.offset == offset; + } + + public static bool operator ==(Section a, Section b) + { + return a.Equals(b); + } + + public static bool operator !=(Section a, Section b) + { + return !(a == b); + } + + public override int GetHashCode() + { + return base.GetHashCode(); + } + + /// + /// + public static string ToString(Section value) + { + return "Section{0x" + Convert.ToString(value.Mask, 16) + ", 0x" + Convert.ToString(value.Offset, 16) + "}"; + } + + /// + /// + public override string ToString() + { + return Section.ToString(this); + } + + } + } +} diff --git a/BDInfo/LanguageCodes.cs b/BDInfo/LanguageCodes.cs new file mode 100644 index 0000000000..90d0bccc43 --- /dev/null +++ b/BDInfo/LanguageCodes.cs @@ -0,0 +1,493 @@ +//============================================================================ +// BDInfo - Blu-ray Video and Audio Analysis Tool +// Copyright © 2010 Cinema Squid +// +// This library is free software; you can redistribute it and/or +// modify it under the terms of the GNU Lesser General Public +// License as published by the Free Software Foundation; either +// version 2.1 of the License, or (at your option) any later version. +// +// This library is distributed in the hope that it will be useful, +// but WITHOUT ANY WARRANTY; without even the implied warranty of +// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU +// Lesser General Public License for more details. +// +// You should have received a copy of the GNU Lesser General Public +// License along with this library; if not, write to the Free Software +// Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA +//============================================================================= + + +namespace BDInfo +{ + public abstract class LanguageCodes + { + public static string GetName(string code) + { + switch (code) + { + case "abk": return "Abkhazian"; + case "ace": return "Achinese"; + case "ach": return "Acoli"; + case "ada": return "Adangme"; + case "aar": return "Afar"; + case "afh": return "Afrihili"; + case "afr": return "Afrikaans"; + case "afa": return "Afro-Asiatic (Other)"; + case "aka": return "Akan"; + case "akk": return "Akkadian"; + case "alb": return "Albanian"; + case "sqi": return "Albanian"; + case "ale": return "Aleut"; + case "alg": return "Algonquian languages"; + case "tut": return "Altaic (Other)"; + case "amh": return "Amharic"; + case "apa": return "Apache languages"; + case "ara": return "Arabic"; + case "arc": return "Aramaic"; + case "arp": return "Arapaho"; + case "arn": return "Araucanian"; + case "arw": return "Arawak"; + case "arm": return "Armenian"; + case "hye": return "Armenian"; + case "art": return "Artificial (Other)"; + case "asm": return "Assamese"; + case "ath": return "Athapascan languages"; + case "aus": return "Australian languages"; + case "map": return "Austronesian (Other)"; + case "ava": return "Avaric"; + case "ave": return "Avestan"; + case "awa": return "Awadhi"; + case "aym": return "Aymara"; + case "aze": return "Azerbaijani"; + case "ban": return "Balinese"; + case "bat": return "Baltic (Other)"; + case "bal": return "Baluchi"; + case "bam": return "Bambara"; + case "bai": return "Bamileke languages"; + case "bad": return "Banda"; + case "bnt": return "Bantu (Other)"; + case "bas": return "Basa"; + case "bak": return "Bashkir"; + case "baq": return "Basque"; + case "eus": return "Basque"; + case "btk": return "Batak (Indonesia)"; + case "bej": return "Beja"; + case "bel": return "Belarusian"; + case "bem": return "Bemba"; + case "ben": return "Bengali"; + case "ber": return "Berber (Other)"; + case "bho": return "Bhojpuri"; + case "bih": return "Bihari"; + case "bik": return "Bikol"; + case "bin": return "Bini"; + case "bis": return "Bislama"; + case "bos": return "Bosnian"; + case "bra": return "Braj"; + case "bre": return "Breton"; + case "bug": return "Buginese"; + case "bul": return "Bulgarian"; + case "bua": return "Buriat"; + case "bur": return "Burmese"; + case "mya": return "Burmese"; + case "cad": return "Caddo"; + case "car": return "Carib"; + case "cat": return "Catalan"; + case "cau": return "Caucasian (Other)"; + case "ceb": return "Cebuano"; + case "cel": return "Celtic (Other)"; + case "cai": return "Central American Indian (Other)"; + case "chg": return "Chagatai"; + case "cmc": return "Chamic languages"; + case "cha": return "Chamorro"; + case "che": return "Chechen"; + case "chr": return "Cherokee"; + case "chy": return "Cheyenne"; + case "chb": return "Chibcha"; + case "chi": return "Chinese"; + case "zho": return "Chinese"; + case "chn": return "Chinook jargon"; + case "chp": return "Chipewyan"; + case "cho": return "Choctaw"; + case "chu": return "Church Slavic"; + case "chk": return "Chuukese"; + case "chv": return "Chuvash"; + case "cop": return "Coptic"; + case "cor": return "Cornish"; + case "cos": return "Corsican"; + case "cre": return "Cree"; + case "mus": return "Creek"; + case "crp": return "Creoles and pidgins (Other)"; + case "cpe": return "Creoles and pidgins,"; + case "cpf": return "Creoles and pidgins,"; + case "cpp": return "Creoles and pidgins,"; + case "scr": return "Croatian"; + case "hrv": return "Croatian"; + case "cus": return "Cushitic (Other)"; + case "cze": return "Czech"; + case "ces": return "Czech"; + case "dak": return "Dakota"; + case "dan": return "Danish"; + case "day": return "Dayak"; + case "del": return "Delaware"; + case "din": return "Dinka"; + case "div": return "Divehi"; + case "doi": return "Dogri"; + case "dgr": return "Dogrib"; + case "dra": return "Dravidian (Other)"; + case "dua": return "Duala"; + case "dut": return "Dutch"; + case "nld": return "Dutch"; + case "dum": return "Dutch, Middle (ca. 1050-1350)"; + case "dyu": return "Dyula"; + case "dzo": return "Dzongkha"; + case "efi": return "Efik"; + case "egy": return "Egyptian (Ancient)"; + case "eka": return "Ekajuk"; + case "elx": return "Elamite"; + case "eng": return "English"; + case "enm": return "English, Middle (1100-1500)"; + case "ang": return "English, Old (ca.450-1100)"; + case "epo": return "Esperanto"; + case "est": return "Estonian"; + case "ewe": return "Ewe"; + case "ewo": return "Ewondo"; + case "fan": return "Fang"; + case "fat": return "Fanti"; + case "fao": return "Faroese"; + case "fij": return "Fijian"; + case "fin": return "Finnish"; + case "fiu": return "Finno-Ugrian (Other)"; + case "fon": return "Fon"; + case "fre": return "French"; + case "fra": return "French"; + case "frm": return "French, Middle (ca.1400-1600)"; + case "fro": return "French, Old (842-ca.1400)"; + case "fry": return "Frisian"; + case "fur": return "Friulian"; + case "ful": return "Fulah"; + case "gaa": return "Ga"; + case "glg": return "Gallegan"; + case "lug": return "Ganda"; + case "gay": return "Gayo"; + case "gba": return "Gbaya"; + case "gez": return "Geez"; + case "geo": return "Georgian"; + case "kat": return "Georgian"; + case "ger": return "German"; + case "deu": return "German"; + case "nds": return "Saxon"; + case "gmh": return "German, Middle High (ca.1050-1500)"; + case "goh": return "German, Old High (ca.750-1050)"; + case "gem": return "Germanic (Other)"; + case "gil": return "Gilbertese"; + case "gon": return "Gondi"; + case "gor": return "Gorontalo"; + case "got": return "Gothic"; + case "grb": return "Grebo"; + case "grc": return "Greek, Ancient (to 1453)"; + case "gre": return "Greek"; + case "ell": return "Greek"; + case "grn": return "Guarani"; + case "guj": return "Gujarati"; + case "gwi": return "Gwich´in"; + case "hai": return "Haida"; + case "hau": return "Hausa"; + case "haw": return "Hawaiian"; + case "heb": return "Hebrew"; + case "her": return "Herero"; + case "hil": return "Hiligaynon"; + case "him": return "Himachali"; + case "hin": return "Hindi"; + case "hmo": return "Hiri Motu"; + case "hit": return "Hittite"; + case "hmn": return "Hmong"; + case "hun": return "Hungarian"; + case "hup": return "Hupa"; + case "iba": return "Iban"; + case "ice": return "Icelandic"; + case "isl": return "Icelandic"; + case "ibo": return "Igbo"; + case "ijo": return "Ijo"; + case "ilo": return "Iloko"; + case "inc": return "Indic (Other)"; + case "ine": return "Indo-European (Other)"; + case "ind": return "Indonesian"; + case "ina": return "Interlingua (International"; + case "ile": return "Interlingue"; + case "iku": return "Inuktitut"; + case "ipk": return "Inupiaq"; + case "ira": return "Iranian (Other)"; + case "gle": return "Irish"; + case "mga": return "Irish, Middle (900-1200)"; + case "sga": return "Irish, Old (to 900)"; + case "iro": return "Iroquoian languages"; + case "ita": return "Italian"; + case "jpn": return "Japanese"; + case "jav": return "Javanese"; + case "jrb": return "Judeo-Arabic"; + case "jpr": return "Judeo-Persian"; + case "kab": return "Kabyle"; + case "kac": return "Kachin"; + case "kal": return "Kalaallisut"; + case "kam": return "Kamba"; + case "kan": return "Kannada"; + case "kau": return "Kanuri"; + case "kaa": return "Kara-Kalpak"; + case "kar": return "Karen"; + case "kas": return "Kashmiri"; + case "kaw": return "Kawi"; + case "kaz": return "Kazakh"; + case "kha": return "Khasi"; + case "khm": return "Khmer"; + case "khi": return "Khoisan (Other)"; + case "kho": return "Khotanese"; + case "kik": return "Kikuyu"; + case "kmb": return "Kimbundu"; + case "kin": return "Kinyarwanda"; + case "kir": return "Kirghiz"; + case "kom": return "Komi"; + case "kon": return "Kongo"; + case "kok": return "Konkani"; + case "kor": return "Korean"; + case "kos": return "Kosraean"; + case "kpe": return "Kpelle"; + case "kro": return "Kru"; + case "kua": return "Kuanyama"; + case "kum": return "Kumyk"; + case "kur": return "Kurdish"; + case "kru": return "Kurukh"; + case "kut": return "Kutenai"; + case "lad": return "Ladino"; + case "lah": return "Lahnda"; + case "lam": return "Lamba"; + case "lao": return "Lao"; + case "lat": return "Latin"; + case "lav": return "Latvian"; + case "ltz": return "Letzeburgesch"; + case "lez": return "Lezghian"; + case "lin": return "Lingala"; + case "lit": return "Lithuanian"; + case "loz": return "Lozi"; + case "lub": return "Luba-Katanga"; + case "lua": return "Luba-Lulua"; + case "lui": return "Luiseno"; + case "lun": return "Lunda"; + case "luo": return "Luo (Kenya and Tanzania)"; + case "lus": return "Lushai"; + case "mac": return "Macedonian"; + case "mkd": return "Macedonian"; + case "mad": return "Madurese"; + case "mag": return "Magahi"; + case "mai": return "Maithili"; + case "mak": return "Makasar"; + case "mlg": return "Malagasy"; + case "may": return "Malay"; + case "msa": return "Malay"; + case "mal": return "Malayalam"; + case "mlt": return "Maltese"; + case "mnc": return "Manchu"; + case "mdr": return "Mandar"; + case "man": return "Mandingo"; + case "mni": return "Manipuri"; + case "mno": return "Manobo languages"; + case "glv": return "Manx"; + case "mao": return "Maori"; + case "mri": return "Maori"; + case "mar": return "Marathi"; + case "chm": return "Mari"; + case "mah": return "Marshall"; + case "mwr": return "Marwari"; + case "mas": return "Masai"; + case "myn": return "Mayan languages"; + case "men": return "Mende"; + case "mic": return "Micmac"; + case "min": return "Minangkabau"; + case "mis": return "Miscellaneous languages"; + case "moh": return "Mohawk"; + case "mol": return "Moldavian"; + case "mkh": return "Mon-Khmer (Other)"; + case "lol": return "Mongo"; + case "mon": return "Mongolian"; + case "mos": return "Mossi"; + case "mul": return "Multiple languages"; + case "mun": return "Munda languages"; + case "nah": return "Nahuatl"; + case "nau": return "Nauru"; + case "nav": return "Navajo"; + case "nde": return "Ndebele, North"; + case "nbl": return "Ndebele, South"; + case "ndo": return "Ndonga"; + case "nep": return "Nepali"; + case "new": return "Newari"; + case "nia": return "Nias"; + case "nic": return "Niger-Kordofanian (Other)"; + case "ssa": return "Nilo-Saharan (Other)"; + case "niu": return "Niuean"; + case "non": return "Norse, Old"; + case "nai": return "North American Indian (Other)"; + case "sme": return "Northern Sami"; + case "nor": return "Norwegian"; + case "nob": return "Norwegian Bokmål"; + case "nno": return "Norwegian Nynorsk"; + case "nub": return "Nubian languages"; + case "nym": return "Nyamwezi"; + case "nya": return "Nyanja"; + case "nyn": return "Nyankole"; + case "nyo": return "Nyoro"; + case "nzi": return "Nzima"; + case "oci": return "Occitan"; + case "oji": return "Ojibwa"; + case "ori": return "Oriya"; + case "orm": return "Oromo"; + case "osa": return "Osage"; + case "oss": return "Ossetian"; + case "oto": return "Otomian languages"; + case "pal": return "Pahlavi"; + case "pau": return "Palauan"; + case "pli": return "Pali"; + case "pam": return "Pampanga"; + case "pag": return "Pangasinan"; + case "pan": return "Panjabi"; + case "pap": return "Papiamento"; + case "paa": return "Papuan (Other)"; + case "per": return "Persian"; + case "fas": return "Persian"; + case "peo": return "Persian, Old (ca.600-400 B.C.)"; + case "phi": return "Philippine (Other)"; + case "phn": return "Phoenician"; + case "pon": return "Pohnpeian"; + case "pol": return "Polish"; + case "por": return "Portuguese"; + case "pra": return "Prakrit languages"; + case "pro": return "Provençal"; + case "pus": return "Pushto"; + case "que": return "Quechua"; + case "roh": return "Raeto-Romance"; + case "raj": return "Rajasthani"; + case "rap": return "Rapanui"; + case "rar": return "Rarotongan"; + case "roa": return "Romance (Other)"; + case "rum": return "Romanian"; + case "ron": return "Romanian"; + case "rom": return "Romany"; + case "run": return "Rundi"; + case "rus": return "Russian"; + case "sal": return "Salishan languages"; + case "sam": return "Samaritan Aramaic"; + case "smi": return "Sami languages (Other)"; + case "smo": return "Samoan"; + case "sad": return "Sandawe"; + case "sag": return "Sango"; + case "san": return "Sanskrit"; + case "sat": return "Santali"; + case "srd": return "Sardinian"; + case "sas": return "Sasak"; + case "sco": return "Scots"; + case "gla": return "Gaelic"; + case "sel": return "Selkup"; + case "sem": return "Semitic (Other)"; + case "scc": return "Serbian"; + case "srp": return "Serbian"; + case "srr": return "Serer"; + case "shn": return "Shan"; + case "sna": return "Shona"; + case "sid": return "Sidamo"; + case "sgn": return "Sign languages"; + case "bla": return "Siksika"; + case "snd": return "Sindhi"; + case "sin": return "Sinhalese"; + case "sit": return "Sino-Tibetan (Other)"; + case "sio": return "Siouan languages"; + case "den": return "Slave (Athapascan)"; + case "sla": return "Slavic (Other)"; + case "slo": return "Slovak"; + case "slk": return "Slovak"; + case "slv": return "Slovenian"; + case "sog": return "Sogdian"; + case "som": return "Somali"; + case "son": return "Songhai"; + case "snk": return "Soninke"; + case "wen": return "Sorbian languages"; + case "nso": return "Sotho, Northern"; + case "sot": return "Sotho, Southern"; + case "sai": return "South American Indian (Other)"; + case "spa": return "Spanish"; + case "suk": return "Sukuma"; + case "sux": return "Sumerian"; + case "sun": return "Sundanese"; + case "sus": return "Susu"; + case "swa": return "Swahili"; + case "ssw": return "Swati"; + case "swe": return "Swedish"; + case "syr": return "Syriac"; + case "tgl": return "Tagalog"; + case "tah": return "Tahitian"; + case "tai": return "Tai (Other)"; + case "tgk": return "Tajik"; + case "tmh": return "Tamashek"; + case "tam": return "Tamil"; + case "tat": return "Tatar"; + case "tel": return "Telugu"; + case "ter": return "Tereno"; + case "tet": return "Tetum"; + case "tha": return "Thai"; + case "tib": return "Tibetan"; + case "bod": return "Tibetan"; + case "tig": return "Tigre"; + case "tir": return "Tigrinya"; + case "tem": return "Timne"; + case "tiv": return "Tiv"; + case "tli": return "Tlingit"; + case "tpi": return "Tok Pisin"; + case "tkl": return "Tokelau"; + case "tog": return "Tonga (Nyasa)"; + case "ton": return "Tonga (Tonga Islands)"; + case "tsi": return "Tsimshian"; + case "tso": return "Tsonga"; + case "tsn": return "Tswana"; + case "tum": return "Tumbuka"; + case "tur": return "Turkish"; + case "ota": return "Turkish, Ottoman (1500-1928)"; + case "tuk": return "Turkmen"; + case "tvl": return "Tuvalu"; + case "tyv": return "Tuvinian"; + case "twi": return "Twi"; + case "uga": return "Ugaritic"; + case "uig": return "Uighur"; + case "ukr": return "Ukrainian"; + case "umb": return "Umbundu"; + case "und": return "Undetermined"; + case "urd": return "Urdu"; + case "uzb": return "Uzbek"; + case "vai": return "Vai"; + case "ven": return "Venda"; + case "vie": return "Vietnamese"; + case "vol": return "Volapük"; + case "vot": return "Votic"; + case "wak": return "Wakashan languages"; + case "wal": return "Walamo"; + case "war": return "Waray"; + case "was": return "Washo"; + case "wel": return "Welsh"; + case "cym": return "Welsh"; + case "wol": return "Wolof"; + case "xho": return "Xhosa"; + case "sah": return "Yakut"; + case "yao": return "Yao"; + case "yap": return "Yapese"; + case "yid": return "Yiddish"; + case "yor": return "Yoruba"; + case "ypk": return "Yupik languages"; + case "znd": return "Zande"; + case "zap": return "Zapotec"; + case "zen": return "Zenaga"; + case "zha": return "Zhuang"; + case "zul": return "Zulu"; + case "zun": return "Zuni"; + + default: return code; + } + } + } +} diff --git a/BDInfo/Properties/AssemblyInfo.cs b/BDInfo/Properties/AssemblyInfo.cs new file mode 100644 index 0000000000..aa44da1909 --- /dev/null +++ b/BDInfo/Properties/AssemblyInfo.cs @@ -0,0 +1,29 @@ +using System.Resources; +using System.Reflection; +using System.Runtime.CompilerServices; +using System.Runtime.InteropServices; + +// General Information about an assembly is controlled through the following +// set of attributes. Change these attribute values to modify the information +// associated with an assembly. +[assembly: AssemblyTitle("BDInfo")] +[assembly: AssemblyDescription("")] +[assembly: AssemblyConfiguration("")] +[assembly: AssemblyCompany("")] +[assembly: AssemblyProduct("BDInfo")] +[assembly: AssemblyCopyright("Copyright © 2016")] +[assembly: AssemblyTrademark("")] +[assembly: AssemblyCulture("")] +[assembly: NeutralResourcesLanguage("en")] + +// Version information for an assembly consists of the following four values: +// +// Major Version +// Minor Version +// Build Number +// Revision +// +// You can specify all the values or you can default the Build and Revision Numbers +// by using the '*' as shown below: +// [assembly: AssemblyVersion("1.0.*")] +[assembly: AssemblyVersion("1.0.1")] \ No newline at end of file diff --git a/BDInfo/ReadMe.txt b/BDInfo/ReadMe.txt new file mode 100644 index 0000000000..68326d560a --- /dev/null +++ b/BDInfo/ReadMe.txt @@ -0,0 +1,5 @@ +The source is taken from the BDRom folder of this project: + +http://www.cinemasquid.com/blu-ray/tools/bdinfo + +BDInfoSettings was taken from the FormSettings class, and changed so that the settings all return defaults. \ No newline at end of file diff --git a/BDInfo/TSCodecAC3.cs b/BDInfo/TSCodecAC3.cs new file mode 100644 index 0000000000..144141c302 --- /dev/null +++ b/BDInfo/TSCodecAC3.cs @@ -0,0 +1,309 @@ +//============================================================================ +// BDInfo - Blu-ray Video and Audio Analysis Tool +// Copyright © 2010 Cinema Squid +// +// This library is free software; you can redistribute it and/or +// modify it under the terms of the GNU Lesser General Public +// License as published by the Free Software Foundation; either +// version 2.1 of the License, or (at your option) any later version. +// +// This library is distributed in the hope that it will be useful, +// but WITHOUT ANY WARRANTY; without even the implied warranty of +// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU +// Lesser General Public License for more details. +// +// You should have received a copy of the GNU Lesser General Public +// License along with this library; if not, write to the Free Software +// Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA +//============================================================================= + +#undef DEBUG +using System.IO; + +namespace BDInfo +{ + public abstract class TSCodecAC3 + { + private static byte[] eac3_blocks = new byte[] { 1, 2, 3, 6 }; + + public static void Scan( + TSAudioStream stream, + TSStreamBuffer buffer, + ref string tag) + { + if (stream.IsInitialized) return; + + byte[] sync = buffer.ReadBytes(2); + if (sync == null || + sync[0] != 0x0B || + sync[1] != 0x77) + { + return; + } + + int sr_code = 0; + int frame_size = 0; + int frame_size_code = 0; + int channel_mode = 0; + int lfe_on = 0; + int dial_norm = 0; + int num_blocks = 0; + + byte[] hdr = buffer.ReadBytes(4); + int bsid = (hdr[3] & 0xF8) >> 3; + buffer.Seek(-4, SeekOrigin.Current); + if (bsid <= 10) + { + byte[] crc = buffer.ReadBytes(2); + sr_code = buffer.ReadBits(2); + frame_size_code = buffer.ReadBits(6); + bsid = buffer.ReadBits(5); + int bsmod = buffer.ReadBits(3); + + channel_mode = buffer.ReadBits(3); + int cmixlev = 0; + if (((channel_mode & 0x1) > 0) && (channel_mode != 0x1)) + { + cmixlev = buffer.ReadBits(2); + } + int surmixlev = 0; + if ((channel_mode & 0x4) > 0) + { + surmixlev = buffer.ReadBits(2); + } + int dsurmod = 0; + if (channel_mode == 0x2) + { + dsurmod = buffer.ReadBits(2); + if (dsurmod == 0x2) + { + stream.AudioMode = TSAudioMode.Surround; + } + } + lfe_on = buffer.ReadBits(1); + dial_norm = buffer.ReadBits(5); + int compr = 0; + if (1 == buffer.ReadBits(1)) + { + compr = buffer.ReadBits(8); + } + int langcod = 0; + if (1 == buffer.ReadBits(1)) + { + langcod = buffer.ReadBits(8); + } + int mixlevel = 0; + int roomtyp = 0; + if (1 == buffer.ReadBits(1)) + { + mixlevel = buffer.ReadBits(5); + roomtyp = buffer.ReadBits(2); + } + if (channel_mode == 0) + { + int dialnorm2 = buffer.ReadBits(5); + int compr2 = 0; + if (1 == buffer.ReadBits(1)) + { + compr2 = buffer.ReadBits(8); + } + int langcod2 = 0; + if (1 == buffer.ReadBits(1)) + { + langcod2 = buffer.ReadBits(8); + } + int mixlevel2 = 0; + int roomtyp2 = 0; + if (1 == buffer.ReadBits(1)) + { + mixlevel2 = buffer.ReadBits(5); + roomtyp2 = buffer.ReadBits(2); + } + } + int copyrightb = buffer.ReadBits(1); + int origbs = buffer.ReadBits(1); + if (bsid == 6) + { + if (1 == buffer.ReadBits(1)) + { + int dmixmod = buffer.ReadBits(2); + int ltrtcmixlev = buffer.ReadBits(3); + int ltrtsurmixlev = buffer.ReadBits(3); + int lorocmixlev = buffer.ReadBits(3); + int lorosurmixlev = buffer.ReadBits(3); + } + if (1 == buffer.ReadBits(1)) + { + int dsurexmod = buffer.ReadBits(2); + int dheadphonmod = buffer.ReadBits(2); + if (dheadphonmod == 0x2) + { + // TODO + } + int adconvtyp = buffer.ReadBits(1); + int xbsi2 = buffer.ReadBits(8); + int encinfo = buffer.ReadBits(1); + if (dsurexmod == 2) + { + stream.AudioMode = TSAudioMode.Extended; + } + } + } + } + else + { + int frame_type = buffer.ReadBits(2); + int substreamid = buffer.ReadBits(3); + frame_size = (buffer.ReadBits(11) + 1) << 1; + + sr_code = buffer.ReadBits(2); + if (sr_code == 3) + { + sr_code = buffer.ReadBits(2); + } + else + { + num_blocks = buffer.ReadBits(2); + } + channel_mode = buffer.ReadBits(3); + lfe_on = buffer.ReadBits(1); + } + + switch (channel_mode) + { + case 0: // 1+1 + stream.ChannelCount = 2; + if (stream.AudioMode == TSAudioMode.Unknown) + { + stream.AudioMode = TSAudioMode.DualMono; + } + break; + case 1: // 1/0 + stream.ChannelCount = 1; + break; + case 2: // 2/0 + stream.ChannelCount = 2; + if (stream.AudioMode == TSAudioMode.Unknown) + { + stream.AudioMode = TSAudioMode.Stereo; + } + break; + case 3: // 3/0 + stream.ChannelCount = 3; + break; + case 4: // 2/1 + stream.ChannelCount = 3; + break; + case 5: // 3/1 + stream.ChannelCount = 4; + break; + case 6: // 2/2 + stream.ChannelCount = 4; + break; + case 7: // 3/2 + stream.ChannelCount = 5; + break; + default: + stream.ChannelCount = 0; + break; + } + + switch (sr_code) + { + case 0: + stream.SampleRate = 48000; + break; + case 1: + stream.SampleRate = 44100; + break; + case 2: + stream.SampleRate = 32000; + break; + default: + stream.SampleRate = 0; + break; + } + + if (bsid <= 10) + { + switch (frame_size_code >> 1) + { + case 18: + stream.BitRate = 640000; + break; + case 17: + stream.BitRate = 576000; + break; + case 16: + stream.BitRate = 512000; + break; + case 15: + stream.BitRate = 448000; + break; + case 14: + stream.BitRate = 384000; + break; + case 13: + stream.BitRate = 320000; + break; + case 12: + stream.BitRate = 256000; + break; + case 11: + stream.BitRate = 224000; + break; + case 10: + stream.BitRate = 192000; + break; + case 9: + stream.BitRate = 160000; + break; + case 8: + stream.BitRate = 128000; + break; + case 7: + stream.BitRate = 112000; + break; + case 6: + stream.BitRate = 96000; + break; + case 5: + stream.BitRate = 80000; + break; + case 4: + stream.BitRate = 64000; + break; + case 3: + stream.BitRate = 56000; + break; + case 2: + stream.BitRate = 48000; + break; + case 1: + stream.BitRate = 40000; + break; + case 0: + stream.BitRate = 32000; + break; + default: + stream.BitRate = 0; + break; + } + } + else + { + stream.BitRate = (long) + (4.0 * frame_size * stream.SampleRate / (num_blocks * 256)); + } + + stream.LFE = lfe_on; + if (stream.StreamType != TSStreamType.AC3_PLUS_AUDIO && + stream.StreamType != TSStreamType.AC3_PLUS_SECONDARY_AUDIO) + { + stream.DialNorm = dial_norm - 31; + } + stream.IsVBR = false; + stream.IsInitialized = true; + } + } +} diff --git a/BDInfo/TSCodecAVC.cs b/BDInfo/TSCodecAVC.cs new file mode 100644 index 0000000000..43c6d6f857 --- /dev/null +++ b/BDInfo/TSCodecAVC.cs @@ -0,0 +1,148 @@ +//============================================================================ +// BDInfo - Blu-ray Video and Audio Analysis Tool +// Copyright © 2010 Cinema Squid +// +// This library is free software; you can redistribute it and/or +// modify it under the terms of the GNU Lesser General Public +// License as published by the Free Software Foundation; either +// version 2.1 of the License, or (at your option) any later version. +// +// This library is distributed in the hope that it will be useful, +// but WITHOUT ANY WARRANTY; without even the implied warranty of +// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU +// Lesser General Public License for more details. +// +// You should have received a copy of the GNU Lesser General Public +// License along with this library; if not, write to the Free Software +// Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA +//============================================================================= + + +namespace BDInfo +{ + public abstract class TSCodecAVC + { + public static void Scan( + TSVideoStream stream, + TSStreamBuffer buffer, + ref string tag) + { + uint parse = 0; + byte accessUnitDelimiterParse = 0; + byte sequenceParameterSetParse = 0; + string profile = null; + string level = null; + byte constraintSet0Flag = 0; + byte constraintSet1Flag = 0; + byte constraintSet2Flag = 0; + byte constraintSet3Flag = 0; + + for (int i = 0; i < buffer.Length; i++) + { + parse = (parse << 8) + buffer.ReadByte(); + + if (parse == 0x00000109) + { + accessUnitDelimiterParse = 1; + } + else if (accessUnitDelimiterParse > 0) + { + --accessUnitDelimiterParse; + if (accessUnitDelimiterParse == 0) + { + switch ((parse & 0xFF) >> 5) + { + case 0: // I + case 3: // SI + case 5: // I, SI + tag = "I"; + break; + + case 1: // I, P + case 4: // SI, SP + case 6: // I, SI, P, SP + tag = "P"; + break; + + case 2: // I, P, B + case 7: // I, SI, P, SP, B + tag = "B"; + break; + } + if (stream.IsInitialized) return; + } + } + else if (parse == 0x00000127 || parse == 0x00000167) + { + sequenceParameterSetParse = 3; + } + else if (sequenceParameterSetParse > 0) + { + --sequenceParameterSetParse; + switch (sequenceParameterSetParse) + { + case 2: + switch (parse & 0xFF) + { + case 66: + profile = "Baseline Profile"; + break; + case 77: + profile = "Main Profile"; + break; + case 88: + profile = "Extended Profile"; + break; + case 100: + profile = "High Profile"; + break; + case 110: + profile = "High 10 Profile"; + break; + case 122: + profile = "High 4:2:2 Profile"; + break; + case 144: + profile = "High 4:4:4 Profile"; + break; + default: + profile = "Unknown Profile"; + break; + } + break; + + case 1: + constraintSet0Flag = (byte) + ((parse & 0x80) >> 7); + constraintSet1Flag = (byte) + ((parse & 0x40) >> 6); + constraintSet2Flag = (byte) + ((parse & 0x20) >> 5); + constraintSet3Flag = (byte) + ((parse & 0x10) >> 4); + break; + + case 0: + byte b = (byte)(parse & 0xFF); + if (b == 11 && constraintSet3Flag == 1) + { + level = "1b"; + } + else + { + level = string.Format( + "{0:D}.{1:D}", + b / 10, (b - ((b / 10) * 10))); + } + stream.EncodingProfile = string.Format( + "{0} {1}", profile, level); + stream.IsVBR = true; + stream.IsInitialized = true; + break; + } + } + } + return; + } + } +} diff --git a/BDInfo/TSCodecDTS.cs b/BDInfo/TSCodecDTS.cs new file mode 100644 index 0000000000..58eb60fc59 --- /dev/null +++ b/BDInfo/TSCodecDTS.cs @@ -0,0 +1,159 @@ +//============================================================================ +// BDInfo - Blu-ray Video and Audio Analysis Tool +// Copyright © 2010 Cinema Squid +// +// This library is free software; you can redistribute it and/or +// modify it under the terms of the GNU Lesser General Public +// License as published by the Free Software Foundation; either +// version 2.1 of the License, or (at your option) any later version. +// +// This library is distributed in the hope that it will be useful, +// but WITHOUT ANY WARRANTY; without even the implied warranty of +// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU +// Lesser General Public License for more details. +// +// You should have received a copy of the GNU Lesser General Public +// License along with this library; if not, write to the Free Software +// Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA +//============================================================================= + + +namespace BDInfo +{ + public abstract class TSCodecDTS + { + private static int[] dca_sample_rates = + { + 0, 8000, 16000, 32000, 0, 0, 11025, 22050, 44100, 0, 0, + 12000, 24000, 48000, 96000, 192000 + }; + + private static int[] dca_bit_rates = + { + 32000, 56000, 64000, 96000, 112000, 128000, + 192000, 224000, 256000, 320000, 384000, + 448000, 512000, 576000, 640000, 768000, + 896000, 1024000, 1152000, 1280000, 1344000, + 1408000, 1411200, 1472000, 1509000, 1920000, + 2048000, 3072000, 3840000, 1/*open*/, 2/*variable*/, 3/*lossless*/ + }; + + private static int[] dca_channels = + { + 1, 2, 2, 2, 2, 3, 3, 4, 4, 5, 6, 6, 6, 7, 8, 8 + }; + + private static int[] dca_bits_per_sample = + { + 16, 16, 20, 20, 0, 24, 24 + }; + + public static void Scan( + TSAudioStream stream, + TSStreamBuffer buffer, + long bitrate, + ref string tag) + { + if (stream.IsInitialized) return; + + bool syncFound = false; + uint sync = 0; + for (int i = 0; i < buffer.Length; i++) + { + sync = (sync << 8) + buffer.ReadByte(); + if (sync == 0x7FFE8001) + { + syncFound = true; + break; + } + } + if (!syncFound) return; + + int frame_type = buffer.ReadBits(1); + int samples_deficit = buffer.ReadBits(5); + int crc_present = buffer.ReadBits(1); + int sample_blocks = buffer.ReadBits(7); + int frame_size = buffer.ReadBits(14); + if (frame_size < 95) + { + return; + } + int amode = buffer.ReadBits(6); + int sample_rate = buffer.ReadBits(4); + if (sample_rate < 0 || sample_rate >= dca_sample_rates.Length) + { + return; + } + int bit_rate = buffer.ReadBits(5); + if (bit_rate < 0 || bit_rate >= dca_bit_rates.Length) + { + return; + } + int downmix = buffer.ReadBits(1); + int dynrange = buffer.ReadBits(1); + int timestamp = buffer.ReadBits(1); + int aux_data = buffer.ReadBits(1); + int hdcd = buffer.ReadBits(1); + int ext_descr = buffer.ReadBits(3); + int ext_coding = buffer.ReadBits(1); + int aspf = buffer.ReadBits(1); + int lfe = buffer.ReadBits(2); + int predictor_history = buffer.ReadBits(1); + if (crc_present == 1) + { + int crc = buffer.ReadBits(16); + } + int multirate_inter = buffer.ReadBits(1); + int version = buffer.ReadBits(4); + int copy_history = buffer.ReadBits(2); + int source_pcm_res = buffer.ReadBits(3); + int front_sum = buffer.ReadBits(1); + int surround_sum = buffer.ReadBits(1); + int dialog_norm = buffer.ReadBits(4); + if (source_pcm_res < 0 || source_pcm_res >= dca_bits_per_sample.Length) + { + return; + } + int subframes = buffer.ReadBits(4); + int total_channels = buffer.ReadBits(3) + 1 + ext_coding; + + stream.SampleRate = dca_sample_rates[sample_rate]; + stream.ChannelCount = total_channels; + stream.LFE = (lfe > 0 ? 1 : 0); + stream.BitDepth = dca_bits_per_sample[source_pcm_res]; + stream.DialNorm = -dialog_norm; + if ((source_pcm_res & 0x1) == 0x1) + { + stream.AudioMode = TSAudioMode.Extended; + } + + stream.BitRate = (uint)dca_bit_rates[bit_rate]; + switch (stream.BitRate) + { + case 1: + if (bitrate > 0) + { + stream.BitRate = bitrate; + stream.IsVBR = false; + stream.IsInitialized = true; + } + else + { + stream.BitRate = 0; + } + break; + + case 2: + case 3: + stream.IsVBR = true; + stream.IsInitialized = true; + break; + + default: + stream.IsVBR = false; + stream.IsInitialized = true; + break; + } + } + } +} diff --git a/BDInfo/TSCodecDTSHD.cs b/BDInfo/TSCodecDTSHD.cs new file mode 100644 index 0000000000..169a8077f2 --- /dev/null +++ b/BDInfo/TSCodecDTSHD.cs @@ -0,0 +1,246 @@ +//============================================================================ +// BDInfo - Blu-ray Video and Audio Analysis Tool +// Copyright © 2010 Cinema Squid +// +// This library is free software; you can redistribute it and/or +// modify it under the terms of the GNU Lesser General Public +// License as published by the Free Software Foundation; either +// version 2.1 of the License, or (at your option) any later version. +// +// This library is distributed in the hope that it will be useful, +// but WITHOUT ANY WARRANTY; without even the implied warranty of +// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU +// Lesser General Public License for more details. +// +// You should have received a copy of the GNU Lesser General Public +// License along with this library; if not, write to the Free Software +// Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA +//============================================================================= + + +namespace BDInfo +{ + public abstract class TSCodecDTSHD + { + private static int[] SampleRates = new int[] + { 0x1F40, 0x3E80, 0x7D00, 0x0FA00, 0x1F400, 0x5622, 0x0AC44, 0x15888, 0x2B110, 0x56220, 0x2EE0, 0x5DC0, 0x0BB80, 0x17700, 0x2EE00, 0x5DC00 }; + + public static void Scan( + TSAudioStream stream, + TSStreamBuffer buffer, + long bitrate, + ref string tag) + { + if (stream.IsInitialized && + (stream.StreamType == TSStreamType.DTS_HD_SECONDARY_AUDIO || + (stream.CoreStream != null && + stream.CoreStream.IsInitialized))) return; + + bool syncFound = false; + uint sync = 0; + for (int i = 0; i < buffer.Length; i++) + { + sync = (sync << 8) + buffer.ReadByte(); + if (sync == 0x64582025) + { + syncFound = true; + break; + } + } + + if (!syncFound) + { + tag = "CORE"; + if (stream.CoreStream == null) + { + stream.CoreStream = new TSAudioStream(); + stream.CoreStream.StreamType = TSStreamType.DTS_AUDIO; + } + if (!stream.CoreStream.IsInitialized) + { + buffer.BeginRead(); + TSCodecDTS.Scan(stream.CoreStream, buffer, bitrate, ref tag); + } + return; + } + + tag = "HD"; + int temp1 = buffer.ReadBits(8); + int nuSubStreamIndex = buffer.ReadBits(2); + int nuExtSSHeaderSize = 0; + int nuExtSSFSize = 0; + int bBlownUpHeader = buffer.ReadBits(1); + if (1 == bBlownUpHeader) + { + nuExtSSHeaderSize = buffer.ReadBits(12) + 1; + nuExtSSFSize = buffer.ReadBits(20) + 1; + } + else + { + nuExtSSHeaderSize = buffer.ReadBits(8) + 1; + nuExtSSFSize = buffer.ReadBits(16) + 1; + } + int nuNumAudioPresent = 1; + int nuNumAssets = 1; + int bStaticFieldsPresent = buffer.ReadBits(1); + if (1 == bStaticFieldsPresent) + { + int nuRefClockCode = buffer.ReadBits(2); + int nuExSSFrameDurationCode = buffer.ReadBits(3) + 1; + long nuTimeStamp = 0; + if (1 == buffer.ReadBits(1)) + { + nuTimeStamp = (buffer.ReadBits(18) << 18) + buffer.ReadBits(18); + } + nuNumAudioPresent = buffer.ReadBits(3) + 1; + nuNumAssets = buffer.ReadBits(3) + 1; + int[] nuActiveExSSMask = new int[nuNumAudioPresent]; + for (int i = 0; i < nuNumAudioPresent; i++) + { + nuActiveExSSMask[i] = buffer.ReadBits(nuSubStreamIndex + 1); //? + } + for (int i = 0; i < nuNumAudioPresent; i++) + { + for (int j = 0; j < nuSubStreamIndex + 1; j++) + { + if (((j + 1) % 2) == 1) + { + int mask = buffer.ReadBits(8); + } + } + } + if (1 == buffer.ReadBits(1)) + { + int nuMixMetadataAdjLevel = buffer.ReadBits(2); + int nuBits4MixOutMask = buffer.ReadBits(2) * 4 + 4; + int nuNumMixOutConfigs = buffer.ReadBits(2) + 1; + int[] nuMixOutChMask = new int[nuNumMixOutConfigs]; + for (int i = 0; i < nuNumMixOutConfigs; i++) + { + nuMixOutChMask[i] = buffer.ReadBits(nuBits4MixOutMask); + } + } + } + int[] AssetSizes = new int[nuNumAssets]; + for (int i = 0; i < nuNumAssets; i++) + { + if (1 == bBlownUpHeader) + { + AssetSizes[i] = buffer.ReadBits(20) + 1; + } + else + { + AssetSizes[i] = buffer.ReadBits(16) + 1; + } + } + for (int i = 0; i < nuNumAssets; i++) + { + long bufferPosition = buffer.Position; + int nuAssetDescriptorFSIZE = buffer.ReadBits(9) + 1; + int DescriptorDataForAssetIndex = buffer.ReadBits(3); + if (1 == bStaticFieldsPresent) + { + int AssetTypeDescrPresent = buffer.ReadBits(1); + if (1 == AssetTypeDescrPresent) + { + int AssetTypeDescriptor = buffer.ReadBits(4); + } + int LanguageDescrPresent = buffer.ReadBits(1); + if (1 == LanguageDescrPresent) + { + int LanguageDescriptor = buffer.ReadBits(24); + } + int bInfoTextPresent = buffer.ReadBits(1); + if (1 == bInfoTextPresent) + { + int nuInfoTextByteSize = buffer.ReadBits(10) + 1; + int[] InfoText = new int[nuInfoTextByteSize]; + for (int j = 0; j < nuInfoTextByteSize; j++) + { + InfoText[j] = buffer.ReadBits(8); + } + } + int nuBitResolution = buffer.ReadBits(5) + 1; + int nuMaxSampleRate = buffer.ReadBits(4); + int nuTotalNumChs = buffer.ReadBits(8) + 1; + int bOne2OneMapChannels2Speakers = buffer.ReadBits(1); + int nuSpkrActivityMask = 0; + if (1 == bOne2OneMapChannels2Speakers) + { + int bEmbeddedStereoFlag = 0; + if (nuTotalNumChs > 2) + { + bEmbeddedStereoFlag = buffer.ReadBits(1); + } + int bEmbeddedSixChFlag = 0; + if (nuTotalNumChs > 6) + { + bEmbeddedSixChFlag = buffer.ReadBits(1); + } + int bSpkrMaskEnabled = buffer.ReadBits(1); + int nuNumBits4SAMask = 0; + if (1 == bSpkrMaskEnabled) + { + nuNumBits4SAMask = buffer.ReadBits(2); + nuNumBits4SAMask = nuNumBits4SAMask * 4 + 4; + nuSpkrActivityMask = buffer.ReadBits(nuNumBits4SAMask); + } + // TODO... + } + stream.SampleRate = SampleRates[nuMaxSampleRate]; + stream.BitDepth = nuBitResolution; + + stream.LFE = 0; + if ((nuSpkrActivityMask & 0x8) == 0x8) + { + ++stream.LFE; + } + if ((nuSpkrActivityMask & 0x1000) == 0x1000) + { + ++stream.LFE; + } + stream.ChannelCount = nuTotalNumChs - stream.LFE; + } + if (nuNumAssets > 1) + { + // TODO... + break; + } + } + + // TODO + if (stream.CoreStream != null) + { + TSAudioStream coreStream = (TSAudioStream)stream.CoreStream; + if (coreStream.AudioMode == TSAudioMode.Extended && + stream.ChannelCount == 5) + { + stream.AudioMode = TSAudioMode.Extended; + } + /* + if (coreStream.DialNorm != 0) + { + stream.DialNorm = coreStream.DialNorm; + } + */ + } + + if (stream.StreamType == TSStreamType.DTS_HD_MASTER_AUDIO) + { + stream.IsVBR = true; + stream.IsInitialized = true; + } + else if (bitrate > 0) + { + stream.IsVBR = false; + stream.BitRate = bitrate; + if (stream.CoreStream != null) + { + stream.BitRate += stream.CoreStream.BitRate; + stream.IsInitialized = true; + } + stream.IsInitialized = (stream.BitRate > 0 ? true : false); + } + } + } +} diff --git a/BDInfo/TSCodecLPCM.cs b/BDInfo/TSCodecLPCM.cs new file mode 100644 index 0000000000..d12674f0e8 --- /dev/null +++ b/BDInfo/TSCodecLPCM.cs @@ -0,0 +1,123 @@ +//============================================================================ +// BDInfo - Blu-ray Video and Audio Analysis Tool +// Copyright © 2010 Cinema Squid +// +// This library is free software; you can redistribute it and/or +// modify it under the terms of the GNU Lesser General Public +// License as published by the Free Software Foundation; either +// version 2.1 of the License, or (at your option) any later version. +// +// This library is distributed in the hope that it will be useful, +// but WITHOUT ANY WARRANTY; without even the implied warranty of +// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU +// Lesser General Public License for more details. +// +// You should have received a copy of the GNU Lesser General Public +// License along with this library; if not, write to the Free Software +// Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA +//============================================================================= + + +namespace BDInfo +{ + public abstract class TSCodecLPCM + { + public static void Scan( + TSAudioStream stream, + TSStreamBuffer buffer, + ref string tag) + { + if (stream.IsInitialized) return; + + byte[] header = buffer.ReadBytes(4); + int flags = (header[2] << 8) + header[3]; + + switch ((flags & 0xF000) >> 12) + { + case 1: // 1/0/0 + stream.ChannelCount = 1; + stream.LFE = 0; + break; + case 3: // 2/0/0 + stream.ChannelCount = 2; + stream.LFE = 0; + break; + case 4: // 3/0/0 + stream.ChannelCount = 3; + stream.LFE = 0; + break; + case 5: // 2/1/0 + stream.ChannelCount = 3; + stream.LFE = 0; + break; + case 6: // 3/1/0 + stream.ChannelCount = 4; + stream.LFE = 0; + break; + case 7: // 2/2/0 + stream.ChannelCount = 4; + stream.LFE = 0; + break; + case 8: // 3/2/0 + stream.ChannelCount = 5; + stream.LFE = 0; + break; + case 9: // 3/2/1 + stream.ChannelCount = 5; + stream.LFE = 1; + break; + case 10: // 3/4/0 + stream.ChannelCount = 7; + stream.LFE = 0; + break; + case 11: // 3/4/1 + stream.ChannelCount = 7; + stream.LFE = 1; + break; + default: + stream.ChannelCount = 0; + stream.LFE = 0; + break; + } + + switch ((flags & 0xC0) >> 6) + { + case 1: + stream.BitDepth = 16; + break; + case 2: + stream.BitDepth = 20; + break; + case 3: + stream.BitDepth = 24; + break; + default: + stream.BitDepth = 0; + break; + } + + switch ((flags & 0xF00) >> 8) + { + case 1: + stream.SampleRate = 48000; + break; + case 4: + stream.SampleRate = 96000; + break; + case 5: + stream.SampleRate = 192000; + break; + default: + stream.SampleRate = 0; + break; + } + + stream.BitRate = (uint) + (stream.SampleRate * stream.BitDepth * + (stream.ChannelCount + stream.LFE)); + + stream.IsVBR = false; + stream.IsInitialized = true; + } + } +} diff --git a/BDInfo/TSCodecMPEG2.cs b/BDInfo/TSCodecMPEG2.cs new file mode 100644 index 0000000000..3413a06e92 --- /dev/null +++ b/BDInfo/TSCodecMPEG2.cs @@ -0,0 +1,208 @@ +//============================================================================ +// BDInfo - Blu-ray Video and Audio Analysis Tool +// Copyright © 2010 Cinema Squid +// +// This library is free software; you can redistribute it and/or +// modify it under the terms of the GNU Lesser General Public +// License as published by the Free Software Foundation; either +// version 2.1 of the License, or (at your option) any later version. +// +// This library is distributed in the hope that it will be useful, +// but WITHOUT ANY WARRANTY; without even the implied warranty of +// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU +// Lesser General Public License for more details. +// +// You should have received a copy of the GNU Lesser General Public +// License along with this library; if not, write to the Free Software +// Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA +//============================================================================= + +#undef DEBUG + + +namespace BDInfo +{ + public abstract class TSCodecMPEG2 + { + public static void Scan( + TSVideoStream stream, + TSStreamBuffer buffer, + ref string tag) + { + int parse = 0; + int pictureParse = 0; + int sequenceHeaderParse = 0; + int extensionParse = 0; + int sequenceExtensionParse = 0; + + for (int i = 0; i < buffer.Length; i++) + { + parse = (parse << 8) + buffer.ReadByte(); + + if (parse == 0x00000100) + { + pictureParse = 2; + } + else if (parse == 0x000001B3) + { + sequenceHeaderParse = 7; + } + else if (sequenceHeaderParse > 0) + { + --sequenceHeaderParse; + switch (sequenceHeaderParse) + { +#if DEBUG + case 6: + break; + + case 5: + break; + + case 4: + stream.Width = + (int)((parse & 0xFFF000) >> 12); + stream.Height = + (int)(parse & 0xFFF); + break; + + case 3: + stream.AspectRatio = + (TSAspectRatio)((parse & 0xF0) >> 4); + + switch ((parse & 0xF0) >> 4) + { + case 0: // Forbidden + break; + case 1: // Square + break; + case 2: // 4:3 + break; + case 3: // 16:9 + break; + case 4: // 2.21:1 + break; + default: // Reserved + break; + } + + switch (parse & 0xF) + { + case 0: // Forbidden + break; + case 1: // 23.976 + stream.FrameRateEnumerator = 24000; + stream.FrameRateDenominator = 1001; + break; + case 2: // 24 + stream.FrameRateEnumerator = 24000; + stream.FrameRateDenominator = 1000; + break; + case 3: // 25 + stream.FrameRateEnumerator = 25000; + stream.FrameRateDenominator = 1000; + break; + case 4: // 29.97 + stream.FrameRateEnumerator = 30000; + stream.FrameRateDenominator = 1001; + break; + case 5: // 30 + stream.FrameRateEnumerator = 30000; + stream.FrameRateDenominator = 1000; + break; + case 6: // 50 + stream.FrameRateEnumerator = 50000; + stream.FrameRateDenominator = 1000; + break; + case 7: // 59.94 + stream.FrameRateEnumerator = 60000; + stream.FrameRateDenominator = 1001; + break; + case 8: // 60 + stream.FrameRateEnumerator = 60000; + stream.FrameRateDenominator = 1000; + break; + default: // Reserved + stream.FrameRateEnumerator = 0; + stream.FrameRateDenominator = 0; + break; + } + break; + + case 2: + break; + + case 1: + break; +#endif + + case 0: +#if DEBUG + stream.BitRate = + (((parse & 0xFFFFC0) >> 6) * 200); +#endif + stream.IsVBR = true; + stream.IsInitialized = true; + break; + } + } + else if (pictureParse > 0) + { + --pictureParse; + if (pictureParse == 0) + { + switch ((parse & 0x38) >> 3) + { + case 1: + tag = "I"; + break; + case 2: + tag = "P"; + break; + case 3: + tag = "B"; + break; + default: + break; + } + if (stream.IsInitialized) return; + } + } + else if (parse == 0x000001B5) + { + extensionParse = 1; + } + else if (extensionParse > 0) + { + --extensionParse; + if (extensionParse == 0) + { + if ((parse & 0xF0) == 0x10) + { + sequenceExtensionParse = 1; + } + } + } + else if (sequenceExtensionParse > 0) + { + --sequenceExtensionParse; +#if DEBUG + if (sequenceExtensionParse == 0) + { + uint sequenceExtension = + ((parse & 0x8) >> 3); + if (sequenceExtension == 0) + { + stream.IsInterlaced = true; + } + else + { + stream.IsInterlaced = false; + } + } +#endif + } + } + } + } +} diff --git a/BDInfo/TSCodecMVC.cs b/BDInfo/TSCodecMVC.cs new file mode 100644 index 0000000000..80fed3886c --- /dev/null +++ b/BDInfo/TSCodecMVC.cs @@ -0,0 +1,36 @@ +//============================================================================ +// BDInfo - Blu-ray Video and Audio Analysis Tool +// Copyright © 2010 Cinema Squid +// +// This library is free software; you can redistribute it and/or +// modify it under the terms of the GNU Lesser General Public +// License as published by the Free Software Foundation; either +// version 2.1 of the License, or (at your option) any later version. +// +// This library is distributed in the hope that it will be useful, +// but WITHOUT ANY WARRANTY; without even the implied warranty of +// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU +// Lesser General Public License for more details. +// +// You should have received a copy of the GNU Lesser General Public +// License along with this library; if not, write to the Free Software +// Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA +//============================================================================= + + +namespace BDInfo +{ + // TODO: Do something more interesting here... + + public abstract class TSCodecMVC + { + public static void Scan( + TSVideoStream stream, + TSStreamBuffer buffer, + ref string tag) + { + stream.IsVBR = true; + stream.IsInitialized = true; + } + } +} diff --git a/BDInfo/TSCodecTrueHD.cs b/BDInfo/TSCodecTrueHD.cs new file mode 100644 index 0000000000..baf4fa3dfe --- /dev/null +++ b/BDInfo/TSCodecTrueHD.cs @@ -0,0 +1,186 @@ +//============================================================================ +// BDInfo - Blu-ray Video and Audio Analysis Tool +// Copyright © 2010 Cinema Squid +// +// This library is free software; you can redistribute it and/or +// modify it under the terms of the GNU Lesser General Public +// License as published by the Free Software Foundation; either +// version 2.1 of the License, or (at your option) any later version. +// +// This library is distributed in the hope that it will be useful, +// but WITHOUT ANY WARRANTY; without even the implied warranty of +// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU +// Lesser General Public License for more details. +// +// You should have received a copy of the GNU Lesser General Public +// License along with this library; if not, write to the Free Software +// Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA +//============================================================================= + + +namespace BDInfo +{ + public abstract class TSCodecTrueHD + { + public static void Scan( + TSAudioStream stream, + TSStreamBuffer buffer, + ref string tag) + { + if (stream.IsInitialized && + stream.CoreStream != null && + stream.CoreStream.IsInitialized) return; + + bool syncFound = false; + uint sync = 0; + for (int i = 0; i < buffer.Length; i++) + { + sync = (sync << 8) + buffer.ReadByte(); + if (sync == 0xF8726FBA) + { + syncFound = true; + break; + } + } + + if (!syncFound) + { + tag = "CORE"; + if (stream.CoreStream == null) + { + stream.CoreStream = new TSAudioStream(); + stream.CoreStream.StreamType = TSStreamType.AC3_AUDIO; + } + if (!stream.CoreStream.IsInitialized) + { + buffer.BeginRead(); + TSCodecAC3.Scan(stream.CoreStream, buffer, ref tag); + } + return; + } + + tag = "HD"; + int ratebits = buffer.ReadBits(4); + if (ratebits != 0xF) + { + stream.SampleRate = + (((ratebits & 8) > 0 ? 44100 : 48000) << (ratebits & 7)); + } + int temp1 = buffer.ReadBits(8); + int channels_thd_stream1 = buffer.ReadBits(5); + int temp2 = buffer.ReadBits(2); + + stream.ChannelCount = 0; + stream.LFE = 0; + int c_LFE2 = buffer.ReadBits(1); + if (c_LFE2 == 1) + { + stream.LFE += 1; + } + int c_Cvh = buffer.ReadBits(1); + if (c_Cvh == 1) + { + stream.ChannelCount += 1; + } + int c_LRw = buffer.ReadBits(1); + if (c_LRw == 1) + { + stream.ChannelCount += 2; + } + int c_LRsd = buffer.ReadBits(1); + if (c_LRsd == 1) + { + stream.ChannelCount += 2; + } + int c_Ts = buffer.ReadBits(1); + if (c_Ts == 1) + { + stream.ChannelCount += 1; + } + int c_Cs = buffer.ReadBits(1); + if (c_Cs == 1) + { + stream.ChannelCount += 1; + } + int c_LRrs = buffer.ReadBits(1); + if (c_LRrs == 1) + { + stream.ChannelCount += 2; + } + int c_LRc = buffer.ReadBits(1); + if (c_LRc == 1) + { + stream.ChannelCount += 2; + } + int c_LRvh = buffer.ReadBits(1); + if (c_LRvh == 1) + { + stream.ChannelCount += 2; + } + int c_LRs = buffer.ReadBits(1); + if (c_LRs == 1) + { + stream.ChannelCount += 2; + } + int c_LFE = buffer.ReadBits(1); + if (c_LFE == 1) + { + stream.LFE += 1; + } + int c_C = buffer.ReadBits(1); + if (c_C == 1) + { + stream.ChannelCount += 1; + } + int c_LR = buffer.ReadBits(1); + if (c_LR == 1) + { + stream.ChannelCount += 2; + } + + int access_unit_size = 40 << (ratebits & 7); + int access_unit_size_pow2 = 64 << (ratebits & 7); + + int a1 = buffer.ReadBits(16); + int a2 = buffer.ReadBits(16); + int a3 = buffer.ReadBits(16); + + int is_vbr = buffer.ReadBits(1); + int peak_bitrate = buffer.ReadBits(15); + peak_bitrate = (peak_bitrate * stream.SampleRate) >> 4; + + double peak_bitdepth = + (double)peak_bitrate / + (stream.ChannelCount + stream.LFE) / + stream.SampleRate; + if (peak_bitdepth > 14) + { + stream.BitDepth = 24; + } + else + { + stream.BitDepth = 16; + } + +#if DEBUG + System.Diagnostics.Debug.WriteLine(string.Format( + "{0}\t{1}\t{2:F2}", + stream.PID, peak_bitrate, peak_bitdepth)); +#endif + /* + // TODO: Get THD dialnorm from metadata + if (stream.CoreStream != null) + { + TSAudioStream coreStream = (TSAudioStream)stream.CoreStream; + if (coreStream.DialNorm != 0) + { + stream.DialNorm = coreStream.DialNorm; + } + } + */ + + stream.IsVBR = true; + stream.IsInitialized = true; + } + } +} diff --git a/BDInfo/TSCodecVC1.cs b/BDInfo/TSCodecVC1.cs new file mode 100644 index 0000000000..164ef8c47e --- /dev/null +++ b/BDInfo/TSCodecVC1.cs @@ -0,0 +1,131 @@ +//============================================================================ +// BDInfo - Blu-ray Video and Audio Analysis Tool +// Copyright © 2010 Cinema Squid +// +// This library is free software; you can redistribute it and/or +// modify it under the terms of the GNU Lesser General Public +// License as published by the Free Software Foundation; either +// version 2.1 of the License, or (at your option) any later version. +// +// This library is distributed in the hope that it will be useful, +// but WITHOUT ANY WARRANTY; without even the implied warranty of +// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU +// Lesser General Public License for more details. +// +// You should have received a copy of the GNU Lesser General Public +// License along with this library; if not, write to the Free Software +// Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA +//============================================================================= + + +namespace BDInfo +{ + public abstract class TSCodecVC1 + { + public static void Scan( + TSVideoStream stream, + TSStreamBuffer buffer, + ref string tag) + { + int parse = 0; + byte frameHeaderParse = 0; + byte sequenceHeaderParse = 0; + bool isInterlaced = false; + + for (int i = 0; i < buffer.Length; i++) + { + parse = (parse << 8) + buffer.ReadByte(); + + if (parse == 0x0000010D) + { + frameHeaderParse = 4; + } + else if (frameHeaderParse > 0) + { + --frameHeaderParse; + if (frameHeaderParse == 0) + { + uint pictureType = 0; + if (isInterlaced) + { + if ((parse & 0x80000000) == 0) + { + pictureType = + (uint)((parse & 0x78000000) >> 13); + } + else + { + pictureType = + (uint)((parse & 0x3c000000) >> 12); + } + } + else + { + pictureType = + (uint)((parse & 0xf0000000) >> 14); + } + + if ((pictureType & 0x20000) == 0) + { + tag = "P"; + } + else if ((pictureType & 0x10000) == 0) + { + tag = "B"; + } + else if ((pictureType & 0x8000) == 0) + { + tag = "I"; + } + else if ((pictureType & 0x4000) == 0) + { + tag = "BI"; + } + else + { + tag = null; + } + if (stream.IsInitialized) return; + } + } + else if (parse == 0x0000010F) + { + sequenceHeaderParse = 6; + } + else if (sequenceHeaderParse > 0) + { + --sequenceHeaderParse; + switch (sequenceHeaderParse) + { + case 5: + int profileLevel = ((parse & 0x38) >> 3); + if (((parse & 0xC0) >> 6) == 3) + { + stream.EncodingProfile = string.Format( + "Advanced Profile {0}", profileLevel); + } + else + { + stream.EncodingProfile = string.Format( + "Main Profile {0}", profileLevel); + } + break; + + case 0: + if (((parse & 0x40) >> 6) > 0) + { + isInterlaced = true; + } + else + { + isInterlaced = false; + } + break; + } + stream.IsVBR = true; + stream.IsInitialized = true; + } + } + } + } +} diff --git a/BDInfo/TSInterleavedFile.cs b/BDInfo/TSInterleavedFile.cs new file mode 100644 index 0000000000..9cc338df71 --- /dev/null +++ b/BDInfo/TSInterleavedFile.cs @@ -0,0 +1,37 @@ +//============================================================================ +// BDInfo - Blu-ray Video and Audio Analysis Tool +// Copyright © 2010 Cinema Squid +// +// This library is free software; you can redistribute it and/or +// modify it under the terms of the GNU Lesser General Public +// License as published by the Free Software Foundation; either +// version 2.1 of the License, or (at your option) any later version. +// +// This library is distributed in the hope that it will be useful, +// but WITHOUT ANY WARRANTY; without even the implied warranty of +// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU +// Lesser General Public License for more details. +// +// You should have received a copy of the GNU Lesser General Public +// License along with this library; if not, write to the Free Software +// Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA +//============================================================================= + +using System.IO; + +// TODO: Do more interesting things here... + +namespace BDInfo +{ + public class TSInterleavedFile + { + public FileInfo FileInfo = null; + public string Name = null; + + public TSInterleavedFile(FileInfo fileInfo) + { + FileInfo = fileInfo; + Name = fileInfo.Name.ToUpper(); + } + } +} diff --git a/BDInfo/TSPlaylistFile.cs b/BDInfo/TSPlaylistFile.cs new file mode 100644 index 0000000000..80180dc9b2 --- /dev/null +++ b/BDInfo/TSPlaylistFile.cs @@ -0,0 +1,1284 @@ +//============================================================================ +// BDInfo - Blu-ray Video and Audio Analysis Tool +// Copyright © 2010 Cinema Squid +// +// This library is free software; you can redistribute it and/or +// modify it under the terms of the GNU Lesser General Public +// License as published by the Free Software Foundation; either +// version 2.1 of the License, or (at your option) any later version. +// +// This library is distributed in the hope that it will be useful, +// but WITHOUT ANY WARRANTY; without even the implied warranty of +// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU +// Lesser General Public License for more details. +// +// You should have received a copy of the GNU Lesser General Public +// License along with this library; if not, write to the Free Software +// Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA +//============================================================================= + +#undef DEBUG +using System; +using System.Collections.Generic; +using System.IO; +using System.Text; + +namespace BDInfo +{ + public class TSPlaylistFile + { + private FileInfo FileInfo = null; + public string FileType = null; + public bool IsInitialized = false; + public string Name = null; + public BDROM BDROM = null; + public bool HasHiddenTracks = false; + public bool HasLoops = false; + public bool IsCustom = false; + + public List Chapters = new List(); + + public Dictionary Streams = + new Dictionary(); + public Dictionary PlaylistStreams = + new Dictionary(); + public List StreamClips = + new List(); + public List> AngleStreams = + new List>(); + public List> AngleClips = + new List>(); + public int AngleCount = 0; + + public List SortedStreams = + new List(); + public List VideoStreams = + new List(); + public List AudioStreams = + new List(); + public List TextStreams = + new List(); + public List GraphicsStreams = + new List(); + + public TSPlaylistFile( + BDROM bdrom, + FileInfo fileInfo) + { + BDROM = bdrom; + FileInfo = fileInfo; + Name = fileInfo.Name.ToUpper(); + } + + public TSPlaylistFile( + BDROM bdrom, + string name, + List clips) + { + BDROM = bdrom; + Name = name; + IsCustom = true; + foreach (TSStreamClip clip in clips) + { + TSStreamClip newClip = new TSStreamClip( + clip.StreamFile, clip.StreamClipFile); + + newClip.Name = clip.Name; + newClip.TimeIn = clip.TimeIn; + newClip.TimeOut = clip.TimeOut; + newClip.Length = newClip.TimeOut - newClip.TimeIn; + newClip.RelativeTimeIn = TotalLength; + newClip.RelativeTimeOut = newClip.RelativeTimeIn + newClip.Length; + newClip.AngleIndex = clip.AngleIndex; + newClip.Chapters.Add(clip.TimeIn); + StreamClips.Add(newClip); + + if (newClip.AngleIndex > AngleCount) + { + AngleCount = newClip.AngleIndex; + } + if (newClip.AngleIndex == 0) + { + Chapters.Add(newClip.RelativeTimeIn); + } + } + LoadStreamClips(); + IsInitialized = true; + } + + public override string ToString() + { + return Name; + } + + public ulong InterleavedFileSize + { + get + { + ulong size = 0; + foreach (TSStreamClip clip in StreamClips) + { + size += clip.InterleavedFileSize; + } + return size; + } + } + public ulong FileSize + { + get + { + ulong size = 0; + foreach (TSStreamClip clip in StreamClips) + { + size += clip.FileSize; + } + return size; + } + } + public double TotalLength + { + get + { + double length = 0; + foreach (TSStreamClip clip in StreamClips) + { + if (clip.AngleIndex == 0) + { + length += clip.Length; + } + } + return length; + } + } + + public double TotalAngleLength + { + get + { + double length = 0; + foreach (TSStreamClip clip in StreamClips) + { + length += clip.Length; + } + return length; + } + } + + public ulong TotalSize + { + get + { + ulong size = 0; + foreach (TSStreamClip clip in StreamClips) + { + if (clip.AngleIndex == 0) + { + size += clip.PacketSize; + } + } + return size; + } + } + + public ulong TotalAngleSize + { + get + { + ulong size = 0; + foreach (TSStreamClip clip in StreamClips) + { + size += clip.PacketSize; + } + return size; + } + } + + public ulong TotalBitRate + { + get + { + if (TotalLength > 0) + { + return (ulong)Math.Round(((TotalSize * 8.0) / TotalLength)); + } + return 0; + } + } + + public ulong TotalAngleBitRate + { + get + { + if (TotalAngleLength > 0) + { + return (ulong)Math.Round(((TotalAngleSize * 8.0) / TotalAngleLength)); + } + return 0; + } + } + + public void Scan( + Dictionary streamFiles, + Dictionary streamClipFiles) + { + FileStream fileStream = null; + BinaryReader fileReader = null; + + try + { + Streams.Clear(); + StreamClips.Clear(); + + fileStream = File.OpenRead(FileInfo.FullName); + fileReader = new BinaryReader(fileStream); + + byte[] data = new byte[fileStream.Length]; + int dataLength = fileReader.Read(data, 0, data.Length); + + int pos = 0; + + FileType = ReadString(data, 8, ref pos); + if (FileType != "MPLS0100" && FileType != "MPLS0200") + { + throw new Exception(string.Format( + "Playlist {0} has an unknown file type {1}.", + FileInfo.Name, FileType)); + } + + int playlistOffset = ReadInt32(data, ref pos); + int chaptersOffset = ReadInt32(data, ref pos); + int extensionsOffset = ReadInt32(data, ref pos); + + pos = playlistOffset; + + int playlistLength = ReadInt32(data, ref pos); + int playlistReserved = ReadInt16(data, ref pos); + int itemCount = ReadInt16(data, ref pos); + int subitemCount = ReadInt16(data, ref pos); + + List chapterClips = new List(); + for (int itemIndex = 0; itemIndex < itemCount; itemIndex++) + { + int itemStart = pos; + int itemLength = ReadInt16(data, ref pos); + string itemName = ReadString(data, 5, ref pos); + string itemType = ReadString(data, 4, ref pos); + + TSStreamFile streamFile = null; + string streamFileName = string.Format( + "{0}.M2TS", itemName); + if (streamFiles.ContainsKey(streamFileName)) + { + streamFile = streamFiles[streamFileName]; + } + if (streamFile == null) + { + // Error condition + } + + TSStreamClipFile streamClipFile = null; + string streamClipFileName = string.Format( + "{0}.CLPI", itemName); + if (streamClipFiles.ContainsKey(streamClipFileName)) + { + streamClipFile = streamClipFiles[streamClipFileName]; + } + if (streamClipFile == null) + { + throw new Exception(string.Format( + "Playlist {0} referenced missing file {1}.", + FileInfo.Name, streamFileName)); + } + + pos += 1; + int multiangle = (data[pos] >> 4) & 0x01; + int condition = data[pos] & 0x0F; + pos += 2; + + int inTime = ReadInt32(data, ref pos); + if (inTime < 0) inTime &= 0x7FFFFFFF; + double timeIn = (double)inTime / 45000; + + int outTime = ReadInt32(data, ref pos); + if (outTime < 0) outTime &= 0x7FFFFFFF; + double timeOut = (double)outTime / 45000; + + TSStreamClip streamClip = new TSStreamClip( + streamFile, streamClipFile); + + streamClip.Name = streamFileName; //TODO + streamClip.TimeIn = timeIn; + streamClip.TimeOut = timeOut; + streamClip.Length = streamClip.TimeOut - streamClip.TimeIn; + streamClip.RelativeTimeIn = TotalLength; + streamClip.RelativeTimeOut = streamClip.RelativeTimeIn + streamClip.Length; + StreamClips.Add(streamClip); + chapterClips.Add(streamClip); + + pos += 12; + if (multiangle > 0) + { + int angles = data[pos]; + pos += 2; + for (int angle = 0; angle < angles - 1; angle++) + { + string angleName = ReadString(data, 5, ref pos); + string angleType = ReadString(data, 4, ref pos); + pos += 1; + + TSStreamFile angleFile = null; + string angleFileName = string.Format( + "{0}.M2TS", angleName); + if (streamFiles.ContainsKey(angleFileName)) + { + angleFile = streamFiles[angleFileName]; + } + if (angleFile == null) + { + throw new Exception(string.Format( + "Playlist {0} referenced missing angle file {1}.", + FileInfo.Name, angleFileName)); + } + + TSStreamClipFile angleClipFile = null; + string angleClipFileName = string.Format( + "{0}.CLPI", angleName); + if (streamClipFiles.ContainsKey(angleClipFileName)) + { + angleClipFile = streamClipFiles[angleClipFileName]; + } + if (angleClipFile == null) + { + throw new Exception(string.Format( + "Playlist {0} referenced missing angle file {1}.", + FileInfo.Name, angleClipFileName)); + } + + TSStreamClip angleClip = + new TSStreamClip(angleFile, angleClipFile); + angleClip.AngleIndex = angle + 1; + angleClip.TimeIn = streamClip.TimeIn; + angleClip.TimeOut = streamClip.TimeOut; + angleClip.RelativeTimeIn = streamClip.RelativeTimeIn; + angleClip.RelativeTimeOut = streamClip.RelativeTimeOut; + angleClip.Length = streamClip.Length; + StreamClips.Add(angleClip); + } + if (angles - 1 > AngleCount) AngleCount = angles - 1; + } + + int streamInfoLength = ReadInt16(data, ref pos); + pos += 2; + int streamCountVideo = data[pos++]; + int streamCountAudio = data[pos++]; + int streamCountPG = data[pos++]; + int streamCountIG = data[pos++]; + int streamCountSecondaryAudio = data[pos++]; + int streamCountSecondaryVideo = data[pos++]; + int streamCountPIP = data[pos++]; + pos += 5; + +#if DEBUG + Debug.WriteLine(string.Format( + "{0} : {1} -> V:{2} A:{3} PG:{4} IG:{5} 2A:{6} 2V:{7} PIP:{8}", + Name, streamFileName, streamCountVideo, streamCountAudio, streamCountPG, streamCountIG, + streamCountSecondaryAudio, streamCountSecondaryVideo, streamCountPIP)); +#endif + + for (int i = 0; i < streamCountVideo; i++) + { + TSStream stream = CreatePlaylistStream(data, ref pos); + if (stream != null) PlaylistStreams[stream.PID] = stream; + } + for (int i = 0; i < streamCountAudio; i++) + { + TSStream stream = CreatePlaylistStream(data, ref pos); + if (stream != null) PlaylistStreams[stream.PID] = stream; + } + for (int i = 0; i < streamCountPG; i++) + { + TSStream stream = CreatePlaylistStream(data, ref pos); + if (stream != null) PlaylistStreams[stream.PID] = stream; + } + for (int i = 0; i < streamCountIG; i++) + { + TSStream stream = CreatePlaylistStream(data, ref pos); + if (stream != null) PlaylistStreams[stream.PID] = stream; + } + for (int i = 0; i < streamCountSecondaryAudio; i++) + { + TSStream stream = CreatePlaylistStream(data, ref pos); + if (stream != null) PlaylistStreams[stream.PID] = stream; + pos += 2; + } + for (int i = 0; i < streamCountSecondaryVideo; i++) + { + TSStream stream = CreatePlaylistStream(data, ref pos); + if (stream != null) PlaylistStreams[stream.PID] = stream; + pos += 6; + } + /* + * TODO + * + for (int i = 0; i < streamCountPIP; i++) + { + TSStream stream = CreatePlaylistStream(data, ref pos); + if (stream != null) PlaylistStreams[stream.PID] = stream; + } + */ + + pos += itemLength - (pos - itemStart) + 2; + } + + pos = chaptersOffset + 4; + + int chapterCount = ReadInt16(data, ref pos); + + for (int chapterIndex = 0; + chapterIndex < chapterCount; + chapterIndex++) + { + int chapterType = data[pos+1]; + + if (chapterType == 1) + { + int streamFileIndex = + ((int)data[pos + 2] << 8) + data[pos + 3]; + + long chapterTime = + ((long)data[pos + 4] << 24) + + ((long)data[pos + 5] << 16) + + ((long)data[pos + 6] << 8) + + ((long)data[pos + 7]); + + TSStreamClip streamClip = chapterClips[streamFileIndex]; + + double chapterSeconds = (double)chapterTime / 45000; + + double relativeSeconds = + chapterSeconds - + streamClip.TimeIn + + streamClip.RelativeTimeIn; + + // TODO: Ignore short last chapter? + if (TotalLength - relativeSeconds > 1.0) + { + streamClip.Chapters.Add(chapterSeconds); + this.Chapters.Add(relativeSeconds); + } + } + else + { + // TODO: Handle other chapter types? + } + pos += 14; + } + } + finally + { + if (fileReader != null) + { + fileReader.Dispose(); + } + if (fileStream != null) + { + fileStream.Dispose(); + } + } + } + + public void Initialize() + { + LoadStreamClips(); + + Dictionary> clipTimes = new Dictionary>(); + foreach (TSStreamClip clip in StreamClips) + { + if (clip.AngleIndex == 0) + { + if (clipTimes.ContainsKey(clip.Name)) + { + if (clipTimes[clip.Name].Contains(clip.TimeIn)) + { + HasLoops = true; + break; + } + else + { + clipTimes[clip.Name].Add(clip.TimeIn); + } + } + else + { + clipTimes[clip.Name] = new List { clip.TimeIn }; + } + } + } + ClearBitrates(); + IsInitialized = true; + } + + protected TSStream CreatePlaylistStream(byte[] data, ref int pos) + { + TSStream stream = null; + + int start = pos; + + int headerLength = data[pos++]; + int headerPos = pos; + int headerType = data[pos++]; + + int pid = 0; + int subpathid = 0; + int subclipid = 0; + + switch (headerType) + { + case 1: + pid = ReadInt16(data, ref pos); + break; + case 2: + subpathid = data[pos++]; + subclipid = data[pos++]; + pid = ReadInt16(data, ref pos); + break; + case 3: + subpathid = data[pos++]; + pid = ReadInt16(data, ref pos); + break; + case 4: + subpathid = data[pos++]; + subclipid = data[pos++]; + pid = ReadInt16(data, ref pos); + break; + default: + break; + } + + pos = headerPos + headerLength; + + int streamLength = data[pos++]; + int streamPos = pos; + + TSStreamType streamType = (TSStreamType)data[pos++]; + switch (streamType) + { + case TSStreamType.MVC_VIDEO: + // TODO + break; + + case TSStreamType.AVC_VIDEO: + case TSStreamType.MPEG1_VIDEO: + case TSStreamType.MPEG2_VIDEO: + case TSStreamType.VC1_VIDEO: + + TSVideoFormat videoFormat = (TSVideoFormat) + (data[pos] >> 4); + TSFrameRate frameRate = (TSFrameRate) + (data[pos] & 0xF); + TSAspectRatio aspectRatio = (TSAspectRatio) + (data[pos + 1] >> 4); + + stream = new TSVideoStream(); + ((TSVideoStream)stream).VideoFormat = videoFormat; + ((TSVideoStream)stream).AspectRatio = aspectRatio; + ((TSVideoStream)stream).FrameRate = frameRate; + +#if DEBUG + Debug.WriteLine(string.Format( + "\t{0} {1} {2} {3} {4}", + pid, + streamType, + videoFormat, + frameRate, + aspectRatio)); +#endif + + break; + + case TSStreamType.AC3_AUDIO: + case TSStreamType.AC3_PLUS_AUDIO: + case TSStreamType.AC3_PLUS_SECONDARY_AUDIO: + case TSStreamType.AC3_TRUE_HD_AUDIO: + case TSStreamType.DTS_AUDIO: + case TSStreamType.DTS_HD_AUDIO: + case TSStreamType.DTS_HD_MASTER_AUDIO: + case TSStreamType.DTS_HD_SECONDARY_AUDIO: + case TSStreamType.LPCM_AUDIO: + case TSStreamType.MPEG1_AUDIO: + case TSStreamType.MPEG2_AUDIO: + + int audioFormat = ReadByte(data, ref pos); + + TSChannelLayout channelLayout = (TSChannelLayout) + (audioFormat >> 4); + TSSampleRate sampleRate = (TSSampleRate) + (audioFormat & 0xF); + + string audioLanguage = ReadString(data, 3, ref pos); + + stream = new TSAudioStream(); + ((TSAudioStream)stream).ChannelLayout = channelLayout; + ((TSAudioStream)stream).SampleRate = TSAudioStream.ConvertSampleRate(sampleRate); + ((TSAudioStream)stream).LanguageCode = audioLanguage; + +#if DEBUG + Debug.WriteLine(string.Format( + "\t{0} {1} {2} {3} {4}", + pid, + streamType, + audioLanguage, + channelLayout, + sampleRate)); +#endif + + break; + + case TSStreamType.INTERACTIVE_GRAPHICS: + case TSStreamType.PRESENTATION_GRAPHICS: + + string graphicsLanguage = ReadString(data, 3, ref pos); + + stream = new TSGraphicsStream(); + ((TSGraphicsStream)stream).LanguageCode = graphicsLanguage; + + if (data[pos] != 0) + { + } + +#if DEBUG + Debug.WriteLine(string.Format( + "\t{0} {1} {2}", + pid, + streamType, + graphicsLanguage)); +#endif + + break; + + case TSStreamType.SUBTITLE: + + int code = ReadByte(data, ref pos); // TODO + string textLanguage = ReadString(data, 3, ref pos); + + stream = new TSTextStream(); + ((TSTextStream)stream).LanguageCode = textLanguage; + +#if DEBUG + Debug.WriteLine(string.Format( + "\t{0} {1} {2}", + pid, + streamType, + textLanguage)); +#endif + + break; + + default: + break; + } + + pos = streamPos + streamLength; + + if (stream != null) + { + stream.PID = (ushort)pid; + stream.StreamType = streamType; + } + + return stream; + } + + private void LoadStreamClips() + { + AngleClips.Clear(); + if (AngleCount > 0) + { + for (int angleIndex = 0; angleIndex < AngleCount; angleIndex++) + { + AngleClips.Add(new Dictionary()); + } + } + + TSStreamClip referenceClip = null; + if (StreamClips.Count > 0) + { + referenceClip = StreamClips[0]; + } + foreach (TSStreamClip clip in StreamClips) + { + if (clip.StreamClipFile.Streams.Count > referenceClip.StreamClipFile.Streams.Count) + { + referenceClip = clip; + } + else if (clip.Length > referenceClip.Length) + { + referenceClip = clip; + } + if (AngleCount > 0) + { + if (clip.AngleIndex == 0) + { + for (int angleIndex = 0; angleIndex < AngleCount; angleIndex++) + { + AngleClips[angleIndex][clip.RelativeTimeIn] = clip; + } + } + else + { + AngleClips[clip.AngleIndex - 1][clip.RelativeTimeIn] = clip; + } + } + } + + foreach (TSStream clipStream + in referenceClip.StreamClipFile.Streams.Values) + { + if (!Streams.ContainsKey(clipStream.PID)) + { + TSStream stream = clipStream.Clone(); + Streams[clipStream.PID] = stream; + + if (!IsCustom && !PlaylistStreams.ContainsKey(stream.PID)) + { + stream.IsHidden = true; + HasHiddenTracks = true; + } + + if (stream.IsVideoStream) + { + VideoStreams.Add((TSVideoStream)stream); + } + else if (stream.IsAudioStream) + { + AudioStreams.Add((TSAudioStream)stream); + } + else if (stream.IsGraphicsStream) + { + GraphicsStreams.Add((TSGraphicsStream)stream); + } + else if (stream.IsTextStream) + { + TextStreams.Add((TSTextStream)stream); + } + } + } + + if (referenceClip.StreamFile != null) + { + // TODO: Better way to add this in? + if (BDInfoSettings.EnableSSIF && + referenceClip.StreamFile.InterleavedFile != null && + referenceClip.StreamFile.Streams.ContainsKey(4114) && + !Streams.ContainsKey(4114)) + { + TSStream stream = referenceClip.StreamFile.Streams[4114].Clone(); + Streams[4114] = stream; + if (stream.IsVideoStream) + { + VideoStreams.Add((TSVideoStream)stream); + } + } + + foreach (TSStream clipStream + in referenceClip.StreamFile.Streams.Values) + { + if (Streams.ContainsKey(clipStream.PID)) + { + TSStream stream = Streams[clipStream.PID]; + + if (stream.StreamType != clipStream.StreamType) continue; + + if (clipStream.BitRate > stream.BitRate) + { + stream.BitRate = clipStream.BitRate; + } + stream.IsVBR = clipStream.IsVBR; + + if (stream.IsVideoStream && + clipStream.IsVideoStream) + { + ((TSVideoStream)stream).EncodingProfile = + ((TSVideoStream)clipStream).EncodingProfile; + } + else if (stream.IsAudioStream && + clipStream.IsAudioStream) + { + TSAudioStream audioStream = (TSAudioStream)stream; + TSAudioStream clipAudioStream = (TSAudioStream)clipStream; + + if (clipAudioStream.ChannelCount > audioStream.ChannelCount) + { + audioStream.ChannelCount = clipAudioStream.ChannelCount; + } + if (clipAudioStream.LFE > audioStream.LFE) + { + audioStream.LFE = clipAudioStream.LFE; + } + if (clipAudioStream.SampleRate > audioStream.SampleRate) + { + audioStream.SampleRate = clipAudioStream.SampleRate; + } + if (clipAudioStream.BitDepth > audioStream.BitDepth) + { + audioStream.BitDepth = clipAudioStream.BitDepth; + } + if (clipAudioStream.DialNorm < audioStream.DialNorm) + { + audioStream.DialNorm = clipAudioStream.DialNorm; + } + if (clipAudioStream.AudioMode != TSAudioMode.Unknown) + { + audioStream.AudioMode = clipAudioStream.AudioMode; + } + if (clipAudioStream.CoreStream != null && + audioStream.CoreStream == null) + { + audioStream.CoreStream = (TSAudioStream) + clipAudioStream.CoreStream.Clone(); + } + } + } + } + } + + for (int i = 0; i < AngleCount; i++) + { + AngleStreams.Add(new Dictionary()); + } + + if (!BDInfoSettings.KeepStreamOrder) + { + VideoStreams.Sort(CompareVideoStreams); + } + foreach (TSStream stream in VideoStreams) + { + SortedStreams.Add(stream); + for (int i = 0; i < AngleCount; i++) + { + TSStream angleStream = stream.Clone(); + angleStream.AngleIndex = i + 1; + AngleStreams[i][angleStream.PID] = angleStream; + SortedStreams.Add(angleStream); + } + } + + if (!BDInfoSettings.KeepStreamOrder) + { + AudioStreams.Sort(CompareAudioStreams); + } + foreach (TSStream stream in AudioStreams) + { + SortedStreams.Add(stream); + } + + if (!BDInfoSettings.KeepStreamOrder) + { + GraphicsStreams.Sort(CompareGraphicsStreams); + } + foreach (TSStream stream in GraphicsStreams) + { + SortedStreams.Add(stream); + } + + if (!BDInfoSettings.KeepStreamOrder) + { + TextStreams.Sort(CompareTextStreams); + } + foreach (TSStream stream in TextStreams) + { + SortedStreams.Add(stream); + } + } + + public void ClearBitrates() + { + foreach (TSStreamClip clip in StreamClips) + { + clip.PayloadBytes = 0; + clip.PacketCount = 0; + clip.PacketSeconds = 0; + + if (clip.StreamFile != null) + { + foreach (TSStream stream in clip.StreamFile.Streams.Values) + { + stream.PayloadBytes = 0; + stream.PacketCount = 0; + stream.PacketSeconds = 0; + } + + if (clip.StreamFile != null && + clip.StreamFile.StreamDiagnostics != null) + { + clip.StreamFile.StreamDiagnostics.Clear(); + } + } + } + + foreach (TSStream stream in SortedStreams) + { + stream.PayloadBytes = 0; + stream.PacketCount = 0; + stream.PacketSeconds = 0; + } + } + + public bool IsValid + { + get + { + if (!IsInitialized) return false; + + if (BDInfoSettings.FilterShortPlaylists && + TotalLength < BDInfoSettings.FilterShortPlaylistsValue) + { + return false; + } + + if (HasLoops && + BDInfoSettings.FilterLoopingPlaylists) + { + return false; + } + + return true; + } + } + + public static int CompareVideoStreams( + TSVideoStream x, + TSVideoStream y) + { + if (x == null && y == null) + { + return 0; + } + else if (x == null && y != null) + { + return 1; + } + else if (x != null && y == null) + { + return -1; + } + else + { + if (x.Height > y.Height) + { + return -1; + } + else if (y.Height > x.Height) + { + return 1; + } + else if (x.PID > y.PID) + { + return 1; + } + else if (y.PID > x.PID) + { + return -1; + } + else + { + return 0; + } + } + } + + public static int CompareAudioStreams( + TSAudioStream x, + TSAudioStream y) + { + if (x == y) + { + return 0; + } + else if (x == null && y == null) + { + return 0; + } + else if (x == null && y != null) + { + return -1; + } + else if (x != null && y == null) + { + return 1; + } + else + { + if (x.ChannelCount > y.ChannelCount) + { + return -1; + } + else if (y.ChannelCount > x.ChannelCount) + { + return 1; + } + else + { + int sortX = GetStreamTypeSortIndex(x.StreamType); + int sortY = GetStreamTypeSortIndex(y.StreamType); + + if (sortX > sortY) + { + return -1; + } + else if (sortY > sortX) + { + return 1; + } + else + { + if (x.LanguageCode == "eng") + { + return -1; + } + else if (y.LanguageCode == "eng") + { + return 1; + } + else if (x.LanguageCode != y.LanguageCode) + { + return string.Compare( + x.LanguageName, y.LanguageName); + } + else if (x.PID < y.PID) + { + return -1; + } + else if (y.PID < x.PID) + { + return 1; + } + return 0; + } + } + } + } + + public static int CompareTextStreams( + TSTextStream x, + TSTextStream y) + { + if (x == y) + { + return 0; + } + else if (x == null && y == null) + { + return 0; + } + else if (x == null && y != null) + { + return -1; + } + else if (x != null && y == null) + { + return 1; + } + else + { + if (x.LanguageCode == "eng") + { + return -1; + } + else if (y.LanguageCode == "eng") + { + return 1; + } + else + { + if (x.LanguageCode == y.LanguageCode) + { + if (x.PID > y.PID) + { + return 1; + } + else if (y.PID > x.PID) + { + return -1; + } + else + { + return 0; + } + } + else + { + return string.Compare( + x.LanguageName, y.LanguageName); + } + } + } + } + + private static int CompareGraphicsStreams( + TSGraphicsStream x, + TSGraphicsStream y) + { + if (x == y) + { + return 0; + } + else if (x == null && y == null) + { + return 0; + } + else if (x == null && y != null) + { + return -1; + } + else if (x != null && y == null) + { + return 1; + } + else + { + int sortX = GetStreamTypeSortIndex(x.StreamType); + int sortY = GetStreamTypeSortIndex(y.StreamType); + + if (sortX > sortY) + { + return -1; + } + else if (sortY > sortX) + { + return 1; + } + else if (x.LanguageCode == "eng") + { + return -1; + } + else if (y.LanguageCode == "eng") + { + return 1; + } + else + { + if (x.LanguageCode == y.LanguageCode) + { + if (x.PID > y.PID) + { + return 1; + } + else if (y.PID > x.PID) + { + return -1; + } + else + { + return 0; + } + } + else + { + return string.Compare(x.LanguageName, y.LanguageName); + } + } + } + } + + private static int GetStreamTypeSortIndex(TSStreamType streamType) + { + switch (streamType) + { + case TSStreamType.Unknown: + return 0; + case TSStreamType.MPEG1_VIDEO: + return 1; + case TSStreamType.MPEG2_VIDEO: + return 2; + case TSStreamType.AVC_VIDEO: + return 3; + case TSStreamType.VC1_VIDEO: + return 4; + case TSStreamType.MVC_VIDEO: + return 5; + + case TSStreamType.MPEG1_AUDIO: + return 1; + case TSStreamType.MPEG2_AUDIO: + return 2; + case TSStreamType.AC3_PLUS_SECONDARY_AUDIO: + return 3; + case TSStreamType.DTS_HD_SECONDARY_AUDIO: + return 4; + case TSStreamType.AC3_AUDIO: + return 5; + case TSStreamType.DTS_AUDIO: + return 6; + case TSStreamType.AC3_PLUS_AUDIO: + return 7; + case TSStreamType.DTS_HD_AUDIO: + return 8; + case TSStreamType.AC3_TRUE_HD_AUDIO: + return 9; + case TSStreamType.DTS_HD_MASTER_AUDIO: + return 10; + case TSStreamType.LPCM_AUDIO: + return 11; + + case TSStreamType.SUBTITLE: + return 1; + case TSStreamType.INTERACTIVE_GRAPHICS: + return 2; + case TSStreamType.PRESENTATION_GRAPHICS: + return 3; + + default: + return 0; + } + } + + protected string ReadString( + byte[] data, + int count, + ref int pos) + { + string val = + ASCIIEncoding.ASCII.GetString(data, pos, count); + + pos += count; + + return val; + } + + protected int ReadInt32( + byte[] data, + ref int pos) + { + int val = + ((int)data[pos] << 24) + + ((int)data[pos + 1] << 16) + + ((int)data[pos + 2] << 8) + + ((int)data[pos + 3]); + + pos += 4; + + return val; + } + + protected int ReadInt16( + byte[] data, + ref int pos) + { + int val = + ((int)data[pos] << 8) + + ((int)data[pos + 1]); + + pos += 2; + + return val; + } + + protected byte ReadByte( + byte[] data, + ref int pos) + { + return data[pos++]; + } + } +} diff --git a/BDInfo/TSStream.cs b/BDInfo/TSStream.cs new file mode 100644 index 0000000000..5afb81c5e4 --- /dev/null +++ b/BDInfo/TSStream.cs @@ -0,0 +1,801 @@ +//============================================================================ +// BDInfo - Blu-ray Video and Audio Analysis Tool +// Copyright © 2010 Cinema Squid +// +// This library is free software; you can redistribute it and/or +// modify it under the terms of the GNU Lesser General Public +// License as published by the Free Software Foundation; either +// version 2.1 of the License, or (at your option) any later version. +// +// This library is distributed in the hope that it will be useful, +// but WITHOUT ANY WARRANTY; without even the implied warranty of +// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU +// Lesser General Public License for more details. +// +// You should have received a copy of the GNU Lesser General Public +// License along with this library; if not, write to the Free Software +// Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA +//============================================================================= + +using System; +using System.Collections.Generic; + +namespace BDInfo +{ + public enum TSStreamType : byte + { + Unknown = 0, + MPEG1_VIDEO = 0x01, + MPEG2_VIDEO = 0x02, + AVC_VIDEO = 0x1b, + MVC_VIDEO = 0x20, + VC1_VIDEO = 0xea, + MPEG1_AUDIO = 0x03, + MPEG2_AUDIO = 0x04, + LPCM_AUDIO = 0x80, + AC3_AUDIO = 0x81, + AC3_PLUS_AUDIO = 0x84, + AC3_PLUS_SECONDARY_AUDIO = 0xA1, + AC3_TRUE_HD_AUDIO = 0x83, + DTS_AUDIO = 0x82, + DTS_HD_AUDIO = 0x85, + DTS_HD_SECONDARY_AUDIO = 0xA2, + DTS_HD_MASTER_AUDIO = 0x86, + PRESENTATION_GRAPHICS = 0x90, + INTERACTIVE_GRAPHICS = 0x91, + SUBTITLE = 0x92 + } + + public enum TSVideoFormat : byte + { + Unknown = 0, + VIDEOFORMAT_480i = 1, + VIDEOFORMAT_576i = 2, + VIDEOFORMAT_480p = 3, + VIDEOFORMAT_1080i = 4, + VIDEOFORMAT_720p = 5, + VIDEOFORMAT_1080p = 6, + VIDEOFORMAT_576p = 7, + } + + public enum TSFrameRate : byte + { + Unknown = 0, + FRAMERATE_23_976 = 1, + FRAMERATE_24 = 2, + FRAMERATE_25 = 3, + FRAMERATE_29_97 = 4, + FRAMERATE_50 = 6, + FRAMERATE_59_94 = 7 + } + + public enum TSChannelLayout : byte + { + Unknown = 0, + CHANNELLAYOUT_MONO = 1, + CHANNELLAYOUT_STEREO = 3, + CHANNELLAYOUT_MULTI = 6, + CHANNELLAYOUT_COMBO = 12 + } + + public enum TSSampleRate : byte + { + Unknown = 0, + SAMPLERATE_48 = 1, + SAMPLERATE_96 = 4, + SAMPLERATE_192 = 5, + SAMPLERATE_48_192 = 12, + SAMPLERATE_48_96 = 14 + } + + public enum TSAspectRatio + { + Unknown = 0, + ASPECT_4_3 = 2, + ASPECT_16_9 = 3, + ASPECT_2_21 = 4 + } + + public class TSDescriptor + { + public byte Name; + public byte[] Value; + + public TSDescriptor(byte name, byte length) + { + Name = name; + Value = new byte[length]; + } + + public TSDescriptor Clone() + { + TSDescriptor descriptor = + new TSDescriptor(Name, (byte)Value.Length); + Value.CopyTo(descriptor.Value, 0); + return descriptor; + } + } + + public abstract class TSStream + { + public TSStream() + { + } + + public override string ToString() + { + return string.Format("{0} ({1})", CodecShortName, PID); + } + + public ushort PID; + public TSStreamType StreamType; + public List Descriptors = null; + public long BitRate = 0; + public long ActiveBitRate = 0; + public bool IsVBR = false; + public bool IsInitialized = false; + public string LanguageName; + public bool IsHidden = false; + + public ulong PayloadBytes = 0; + public ulong PacketCount = 0; + public double PacketSeconds = 0; + public int AngleIndex = 0; + + public ulong PacketSize + { + get + { + return PacketCount * 192; + } + } + + private string _LanguageCode; + public string LanguageCode + { + get + { + return _LanguageCode; + } + set + { + _LanguageCode = value; + LanguageName = LanguageCodes.GetName(value); + } + } + + public bool IsVideoStream + { + get + { + switch (StreamType) + { + case TSStreamType.MPEG1_VIDEO: + case TSStreamType.MPEG2_VIDEO: + case TSStreamType.AVC_VIDEO: + case TSStreamType.MVC_VIDEO: + case TSStreamType.VC1_VIDEO: + return true; + + default: + return false; + } + } + } + + public bool IsAudioStream + { + get + { + switch (StreamType) + { + case TSStreamType.MPEG1_AUDIO: + case TSStreamType.MPEG2_AUDIO: + case TSStreamType.LPCM_AUDIO: + case TSStreamType.AC3_AUDIO: + case TSStreamType.AC3_PLUS_AUDIO: + case TSStreamType.AC3_PLUS_SECONDARY_AUDIO: + case TSStreamType.AC3_TRUE_HD_AUDIO: + case TSStreamType.DTS_AUDIO: + case TSStreamType.DTS_HD_AUDIO: + case TSStreamType.DTS_HD_SECONDARY_AUDIO: + case TSStreamType.DTS_HD_MASTER_AUDIO: + return true; + + default: + return false; + } + } + } + + public bool IsGraphicsStream + { + get + { + switch (StreamType) + { + case TSStreamType.PRESENTATION_GRAPHICS: + case TSStreamType.INTERACTIVE_GRAPHICS: + return true; + + default: + return false; + } + } + } + + public bool IsTextStream + { + get + { + switch (StreamType) + { + case TSStreamType.SUBTITLE: + return true; + + default: + return false; + } + } + } + + public string CodecName + { + get + { + switch (StreamType) + { + case TSStreamType.MPEG1_VIDEO: + return "MPEG-1 Video"; + case TSStreamType.MPEG2_VIDEO: + return "MPEG-2 Video"; + case TSStreamType.AVC_VIDEO: + return "MPEG-4 AVC Video"; + case TSStreamType.MVC_VIDEO: + return "MPEG-4 MVC Video"; + case TSStreamType.VC1_VIDEO: + return "VC-1 Video"; + case TSStreamType.MPEG1_AUDIO: + return "MP1 Audio"; + case TSStreamType.MPEG2_AUDIO: + return "MP2 Audio"; + case TSStreamType.LPCM_AUDIO: + return "LPCM Audio"; + case TSStreamType.AC3_AUDIO: + if (((TSAudioStream)this).AudioMode == TSAudioMode.Extended) + return "Dolby Digital EX Audio"; + else + return "Dolby Digital Audio"; + case TSStreamType.AC3_PLUS_AUDIO: + case TSStreamType.AC3_PLUS_SECONDARY_AUDIO: + return "Dolby Digital Plus Audio"; + case TSStreamType.AC3_TRUE_HD_AUDIO: + return "Dolby TrueHD Audio"; + case TSStreamType.DTS_AUDIO: + if (((TSAudioStream)this).AudioMode == TSAudioMode.Extended) + return "DTS-ES Audio"; + else + return "DTS Audio"; + case TSStreamType.DTS_HD_AUDIO: + return "DTS-HD High-Res Audio"; + case TSStreamType.DTS_HD_SECONDARY_AUDIO: + return "DTS Express"; + case TSStreamType.DTS_HD_MASTER_AUDIO: + return "DTS-HD Master Audio"; + case TSStreamType.PRESENTATION_GRAPHICS: + return "Presentation Graphics"; + case TSStreamType.INTERACTIVE_GRAPHICS: + return "Interactive Graphics"; + case TSStreamType.SUBTITLE: + return "Subtitle"; + default: + return "UNKNOWN"; + } + } + } + + public string CodecAltName + { + get + { + switch (StreamType) + { + case TSStreamType.MPEG1_VIDEO: + return "MPEG-1"; + case TSStreamType.MPEG2_VIDEO: + return "MPEG-2"; + case TSStreamType.AVC_VIDEO: + return "AVC"; + case TSStreamType.MVC_VIDEO: + return "MVC"; + case TSStreamType.VC1_VIDEO: + return "VC-1"; + case TSStreamType.MPEG1_AUDIO: + return "MP1"; + case TSStreamType.MPEG2_AUDIO: + return "MP2"; + case TSStreamType.LPCM_AUDIO: + return "LPCM"; + case TSStreamType.AC3_AUDIO: + return "DD AC3"; + case TSStreamType.AC3_PLUS_AUDIO: + case TSStreamType.AC3_PLUS_SECONDARY_AUDIO: + return "DD AC3+"; + case TSStreamType.AC3_TRUE_HD_AUDIO: + return "Dolby TrueHD"; + case TSStreamType.DTS_AUDIO: + return "DTS"; + case TSStreamType.DTS_HD_AUDIO: + return "DTS-HD Hi-Res"; + case TSStreamType.DTS_HD_SECONDARY_AUDIO: + return "DTS Express"; + case TSStreamType.DTS_HD_MASTER_AUDIO: + return "DTS-HD Master"; + case TSStreamType.PRESENTATION_GRAPHICS: + return "PGS"; + case TSStreamType.INTERACTIVE_GRAPHICS: + return "IGS"; + case TSStreamType.SUBTITLE: + return "SUB"; + default: + return "UNKNOWN"; + } + } + } + + public string CodecShortName + { + get + { + switch (StreamType) + { + case TSStreamType.MPEG1_VIDEO: + return "MPEG-1"; + case TSStreamType.MPEG2_VIDEO: + return "MPEG-2"; + case TSStreamType.AVC_VIDEO: + return "AVC"; + case TSStreamType.MVC_VIDEO: + return "MVC"; + case TSStreamType.VC1_VIDEO: + return "VC-1"; + case TSStreamType.MPEG1_AUDIO: + return "MP1"; + case TSStreamType.MPEG2_AUDIO: + return "MP2"; + case TSStreamType.LPCM_AUDIO: + return "LPCM"; + case TSStreamType.AC3_AUDIO: + if (((TSAudioStream)this).AudioMode == TSAudioMode.Extended) + return "AC3-EX"; + else + return "AC3"; + case TSStreamType.AC3_PLUS_AUDIO: + case TSStreamType.AC3_PLUS_SECONDARY_AUDIO: + return "AC3+"; + case TSStreamType.AC3_TRUE_HD_AUDIO: + return "TrueHD"; + case TSStreamType.DTS_AUDIO: + if (((TSAudioStream)this).AudioMode == TSAudioMode.Extended) + return "DTS-ES"; + else + return "DTS"; + case TSStreamType.DTS_HD_AUDIO: + return "DTS-HD HR"; + case TSStreamType.DTS_HD_SECONDARY_AUDIO: + return "DTS Express"; + case TSStreamType.DTS_HD_MASTER_AUDIO: + return "DTS-HD MA"; + case TSStreamType.PRESENTATION_GRAPHICS: + return "PGS"; + case TSStreamType.INTERACTIVE_GRAPHICS: + return "IGS"; + case TSStreamType.SUBTITLE: + return "SUB"; + default: + return "UNKNOWN"; + } + } + } + + public virtual string Description + { + get + { + return ""; + } + } + + public abstract TSStream Clone(); + + protected void CopyTo(TSStream stream) + { + stream.PID = PID; + stream.StreamType = StreamType; + stream.IsVBR = IsVBR; + stream.BitRate = BitRate; + stream.IsInitialized = IsInitialized; + stream.LanguageCode = _LanguageCode; + if (Descriptors != null) + { + stream.Descriptors = new List(); + foreach (TSDescriptor descriptor in Descriptors) + { + stream.Descriptors.Add(descriptor.Clone()); + } + } + } + } + + public class TSVideoStream : TSStream + { + public TSVideoStream() + { + } + + public int Width; + public int Height; + public bool IsInterlaced; + public int FrameRateEnumerator; + public int FrameRateDenominator; + public TSAspectRatio AspectRatio; + public string EncodingProfile; + + private TSVideoFormat _VideoFormat; + public TSVideoFormat VideoFormat + { + get + { + return _VideoFormat; + } + set + { + _VideoFormat = value; + switch (value) + { + case TSVideoFormat.VIDEOFORMAT_480i: + Height = 480; + IsInterlaced = true; + break; + case TSVideoFormat.VIDEOFORMAT_480p: + Height = 480; + IsInterlaced = false; + break; + case TSVideoFormat.VIDEOFORMAT_576i: + Height = 576; + IsInterlaced = true; + break; + case TSVideoFormat.VIDEOFORMAT_576p: + Height = 576; + IsInterlaced = false; + break; + case TSVideoFormat.VIDEOFORMAT_720p: + Height = 720; + IsInterlaced = false; + break; + case TSVideoFormat.VIDEOFORMAT_1080i: + Height = 1080; + IsInterlaced = true; + break; + case TSVideoFormat.VIDEOFORMAT_1080p: + Height = 1080; + IsInterlaced = false; + break; + } + } + } + + private TSFrameRate _FrameRate; + public TSFrameRate FrameRate + { + get + { + return _FrameRate; + } + set + { + _FrameRate = value; + switch (value) + { + case TSFrameRate.FRAMERATE_23_976: + FrameRateEnumerator = 24000; + FrameRateDenominator = 1001; + break; + case TSFrameRate.FRAMERATE_24: + FrameRateEnumerator = 24000; + FrameRateDenominator = 1000; + break; + case TSFrameRate.FRAMERATE_25: + FrameRateEnumerator = 25000; + FrameRateDenominator = 1000; + break; + case TSFrameRate.FRAMERATE_29_97: + FrameRateEnumerator = 30000; + FrameRateDenominator = 1001; + break; + case TSFrameRate.FRAMERATE_50: + FrameRateEnumerator = 50000; + FrameRateDenominator = 1000; + break; + case TSFrameRate.FRAMERATE_59_94: + FrameRateEnumerator = 60000; + FrameRateDenominator = 1001; + break; + } + } + } + + public override string Description + { + get + { + string description = ""; + + if (Height > 0) + { + description += string.Format("{0:D}{1} / ", + Height, + IsInterlaced ? "i" : "p"); + } + if (FrameRateEnumerator > 0 && + FrameRateDenominator > 0) + { + if (FrameRateEnumerator % FrameRateDenominator == 0) + { + description += string.Format("{0:D} fps / ", + FrameRateEnumerator / FrameRateDenominator); + } + else + { + description += string.Format("{0:F3} fps / ", + (double)FrameRateEnumerator / FrameRateDenominator); + } + + } + if (AspectRatio == TSAspectRatio.ASPECT_4_3) + { + description += "4:3 / "; + } + else if (AspectRatio == TSAspectRatio.ASPECT_16_9) + { + description += "16:9 / "; + } + if (EncodingProfile != null) + { + description += EncodingProfile + " / "; + } + if (description.EndsWith(" / ")) + { + description = description.Substring(0, description.Length - 3); + } + return description; + } + } + + public override TSStream Clone() + { + TSVideoStream stream = new TSVideoStream(); + CopyTo(stream); + + stream.VideoFormat = _VideoFormat; + stream.FrameRate = _FrameRate; + stream.Width = Width; + stream.Height = Height; + stream.IsInterlaced = IsInterlaced; + stream.FrameRateEnumerator = FrameRateEnumerator; + stream.FrameRateDenominator = FrameRateDenominator; + stream.AspectRatio = AspectRatio; + stream.EncodingProfile = EncodingProfile; + + return stream; + } + } + + public enum TSAudioMode + { + Unknown, + DualMono, + Stereo, + Surround, + Extended + } + + public class TSAudioStream : TSStream + { + public TSAudioStream() + { + } + + public int SampleRate; + public int ChannelCount; + public int BitDepth; + public int LFE; + public int DialNorm; + public TSAudioMode AudioMode; + public TSAudioStream CoreStream; + public TSChannelLayout ChannelLayout; + + public static int ConvertSampleRate( + TSSampleRate sampleRate) + { + switch (sampleRate) + { + case TSSampleRate.SAMPLERATE_48: + return 48000; + + case TSSampleRate.SAMPLERATE_96: + case TSSampleRate.SAMPLERATE_48_96: + return 96000; + + case TSSampleRate.SAMPLERATE_192: + case TSSampleRate.SAMPLERATE_48_192: + return 192000; + } + return 0; + } + + public string ChannelDescription + { + get + { + if (ChannelLayout == TSChannelLayout.CHANNELLAYOUT_MONO && + ChannelCount == 2) + { + } + + string description = ""; + if (ChannelCount > 0) + { + description += string.Format( + "{0:D}.{1:D}", + ChannelCount, LFE); + } + else + { + switch (ChannelLayout) + { + case TSChannelLayout.CHANNELLAYOUT_MONO: + description += "1.0"; + break; + case TSChannelLayout.CHANNELLAYOUT_STEREO: + description += "2.0"; + break; + case TSChannelLayout.CHANNELLAYOUT_MULTI: + description += "5.1"; + break; + } + } + if (AudioMode == TSAudioMode.Extended) + { + if (StreamType == TSStreamType.AC3_AUDIO) + { + description += "-EX"; + } + if (StreamType == TSStreamType.DTS_AUDIO || + StreamType == TSStreamType.DTS_HD_AUDIO || + StreamType == TSStreamType.DTS_HD_MASTER_AUDIO) + { + description += "-ES"; + } + } + return description; + } + } + + public override string Description + { + get + { + string description = ChannelDescription; + + if (SampleRate > 0) + { + description += string.Format( + " / {0:D} kHz", SampleRate / 1000); + } + if (BitRate > 0) + { + description += string.Format( + " / {0:D} kbps", (uint)Math.Round((double)BitRate / 1000)); + } + if (BitDepth > 0) + { + description += string.Format( + " / {0:D}-bit", BitDepth); + } + if (DialNorm != 0) + { + description += string.Format( + " / DN {0}dB", DialNorm); + } + if (ChannelCount == 2) + { + switch (AudioMode) + { + case TSAudioMode.DualMono: + description += " / Dual Mono"; + break; + + case TSAudioMode.Surround: + description += " / Dolby Surround"; + break; + } + } + if (description.EndsWith(" / ")) + { + description = description.Substring(0, description.Length - 3); + } + if (CoreStream != null) + { + string codec = ""; + switch (CoreStream.StreamType) + { + case TSStreamType.AC3_AUDIO: + codec = "AC3 Embedded"; + break; + case TSStreamType.DTS_AUDIO: + codec = "DTS Core"; + break; + } + description += string.Format( + " ({0}: {1})", + codec, + CoreStream.Description); + } + return description; + } + } + + public override TSStream Clone() + { + TSAudioStream stream = new TSAudioStream(); + CopyTo(stream); + + stream.SampleRate = SampleRate; + stream.ChannelLayout = ChannelLayout; + stream.ChannelCount = ChannelCount; + stream.BitDepth = BitDepth; + stream.LFE = LFE; + stream.DialNorm = DialNorm; + stream.AudioMode = AudioMode; + if (CoreStream != null) + { + stream.CoreStream = (TSAudioStream)CoreStream.Clone(); + } + + return stream; + } + } + + public class TSGraphicsStream : TSStream + { + public TSGraphicsStream() + { + IsVBR = true; + IsInitialized = true; + } + + public override TSStream Clone() + { + TSGraphicsStream stream = new TSGraphicsStream(); + CopyTo(stream); + return stream; + } + } + + public class TSTextStream : TSStream + { + public TSTextStream() + { + IsVBR = true; + IsInitialized = true; + } + + public override TSStream Clone() + { + TSTextStream stream = new TSTextStream(); + CopyTo(stream); + return stream; + } + } +} diff --git a/BDInfo/TSStreamBuffer.cs b/BDInfo/TSStreamBuffer.cs new file mode 100644 index 0000000000..2f9094876e --- /dev/null +++ b/BDInfo/TSStreamBuffer.cs @@ -0,0 +1,142 @@ +//============================================================================ +// BDInfo - Blu-ray Video and Audio Analysis Tool +// Copyright © 2010 Cinema Squid +// +// This library is free software; you can redistribute it and/or +// modify it under the terms of the GNU Lesser General Public +// License as published by the Free Software Foundation; either +// version 2.1 of the License, or (at your option) any later version. +// +// This library is distributed in the hope that it will be useful, +// but WITHOUT ANY WARRANTY; without even the implied warranty of +// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU +// Lesser General Public License for more details. +// +// You should have received a copy of the GNU Lesser General Public +// License along with this library; if not, write to the Free Software +// Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA +//============================================================================= + +using System; +using System.Collections.Specialized; +using System.IO; + +namespace BDInfo +{ + public class TSStreamBuffer + { + private MemoryStream Stream = new MemoryStream(); + private int SkipBits = 0; + private byte[] Buffer; + private int BufferLength = 0; + public int TransferLength = 0; + + public TSStreamBuffer() + { + Buffer = new byte[4096]; + Stream = new MemoryStream(Buffer); + } + + public long Length + { + get + { + return (long)BufferLength; + } + } + + public long Position + { + get + { + return Stream.Position; + } + } + + public void Add( + byte[] buffer, + int offset, + int length) + { + TransferLength += length; + + if (BufferLength + length >= Buffer.Length) + { + length = Buffer.Length - BufferLength; + } + if (length > 0) + { + Array.Copy(buffer, offset, Buffer, BufferLength, length); + BufferLength += length; + } + } + + public void Seek( + long offset, + SeekOrigin loc) + { + Stream.Seek(offset, loc); + } + + public void Reset() + { + BufferLength = 0; + TransferLength = 0; + } + + public void BeginRead() + { + SkipBits = 0; + Stream.Seek(0, SeekOrigin.Begin); + } + + public void EndRead() + { + } + + public byte[] ReadBytes(int bytes) + { + if (Stream.Position + bytes >= BufferLength) + { + return null; + } + + byte[] value = new byte[bytes]; + Stream.Read(value, 0, bytes); + return value; + } + + public byte ReadByte() + { + return (byte)Stream.ReadByte(); + } + + public int ReadBits(int bits) + { + long pos = Stream.Position; + + int shift = 24; + int data = 0; + for (int i = 0; i < 4; i++) + { + if (pos + i >= BufferLength) break; + data += (Stream.ReadByte() << shift); + shift -= 8; + } + BitVector32 vector = new BitVector32(data); + + int value = 0; + for (int i = SkipBits; i < SkipBits + bits; i++) + { + value <<= 1; + value += (vector[1 << (32 - i - 1)] ? 1 : 0); + } + + SkipBits += bits; + Stream.Seek(pos + (SkipBits >> 3), SeekOrigin.Begin); + SkipBits = SkipBits % 8; + + return value; + } + } +} diff --git a/BDInfo/TSStreamClip.cs b/BDInfo/TSStreamClip.cs new file mode 100644 index 0000000000..d7592a71aa --- /dev/null +++ b/BDInfo/TSStreamClip.cs @@ -0,0 +1,113 @@ +//============================================================================ +// BDInfo - Blu-ray Video and Audio Analysis Tool +// Copyright © 2010 Cinema Squid +// +// This library is free software; you can redistribute it and/or +// modify it under the terms of the GNU Lesser General Public +// License as published by the Free Software Foundation; either +// version 2.1 of the License, or (at your option) any later version. +// +// This library is distributed in the hope that it will be useful, +// but WITHOUT ANY WARRANTY; without even the implied warranty of +// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU +// Lesser General Public License for more details. +// +// You should have received a copy of the GNU Lesser General Public +// License along with this library; if not, write to the Free Software +// Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA +//============================================================================= + +using System; +using System.Collections.Generic; + +namespace BDInfo +{ + public class TSStreamClip + { + public int AngleIndex = 0; + public string Name; + public double TimeIn; + public double TimeOut; + public double RelativeTimeIn; + public double RelativeTimeOut; + public double Length; + + public ulong FileSize = 0; + public ulong InterleavedFileSize = 0; + public ulong PayloadBytes = 0; + public ulong PacketCount = 0; + public double PacketSeconds = 0; + + public List Chapters = new List(); + + public TSStreamFile StreamFile = null; + public TSStreamClipFile StreamClipFile = null; + + public TSStreamClip( + TSStreamFile streamFile, + TSStreamClipFile streamClipFile) + { + if (streamFile != null) + { + Name = streamFile.Name; + StreamFile = streamFile; + FileSize = (ulong)StreamFile.FileInfo.Length; + if (StreamFile.InterleavedFile != null) + { + InterleavedFileSize = (ulong)StreamFile.InterleavedFile.FileInfo.Length; + } + } + StreamClipFile = streamClipFile; + } + + public string DisplayName + { + get + { + if (StreamFile != null && + StreamFile.InterleavedFile != null && + BDInfoSettings.EnableSSIF) + { + return StreamFile.InterleavedFile.Name; + } + return Name; + } + } + + public ulong PacketSize + { + get + { + return PacketCount * 192; + } + } + + public ulong PacketBitRate + { + get + { + if (PacketSeconds > 0) + { + return (ulong)Math.Round(((PacketSize * 8.0) / PacketSeconds)); + } + return 0; + } + } + + public bool IsCompatible(TSStreamClip clip) + { + foreach (TSStream stream1 in StreamFile.Streams.Values) + { + if (clip.StreamFile.Streams.ContainsKey(stream1.PID)) + { + TSStream stream2 = clip.StreamFile.Streams[stream1.PID]; + if (stream1.StreamType != stream2.StreamType) + { + return false; + } + } + } + return true; + } + } +} diff --git a/BDInfo/TSStreamClipFile.cs b/BDInfo/TSStreamClipFile.cs new file mode 100644 index 0000000000..dbdf3ea410 --- /dev/null +++ b/BDInfo/TSStreamClipFile.cs @@ -0,0 +1,247 @@ +//============================================================================ +// BDInfo - Blu-ray Video and Audio Analysis Tool +// Copyright © 2010 Cinema Squid +// +// This library is free software; you can redistribute it and/or +// modify it under the terms of the GNU Lesser General Public +// License as published by the Free Software Foundation; either +// version 2.1 of the License, or (at your option) any later version. +// +// This library is distributed in the hope that it will be useful, +// but WITHOUT ANY WARRANTY; without even the implied warranty of +// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU +// Lesser General Public License for more details. +// +// You should have received a copy of the GNU Lesser General Public +// License along with this library; if not, write to the Free Software +// Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA +//============================================================================= + +#undef DEBUG +using System; +using System.Collections.Generic; +using System.IO; +using System.Text; + +namespace BDInfo +{ + public class TSStreamClipFile + { + public FileInfo FileInfo = null; + public string FileType = null; + public bool IsValid = false; + public string Name = null; + + public Dictionary Streams = + new Dictionary(); + + public TSStreamClipFile( + FileInfo fileInfo) + { + FileInfo = fileInfo; + Name = fileInfo.Name.ToUpper(); + } + + public void Scan() + { + FileStream fileStream = null; + BinaryReader fileReader = null; + + try + { +#if DEBUG + Debug.WriteLine(string.Format( + "Scanning {0}...", Name)); +#endif + Streams.Clear(); + + fileStream = File.OpenRead(FileInfo.FullName); + fileReader = new BinaryReader(fileStream); + + byte[] data = new byte[fileStream.Length]; + fileReader.Read(data, 0, data.Length); + + byte[] fileType = new byte[8]; + Array.Copy(data, 0, fileType, 0, fileType.Length); + + FileType = ASCIIEncoding.ASCII.GetString(fileType); + if (FileType != "HDMV0100" && + FileType != "HDMV0200") + { + throw new Exception(string.Format( + "Clip info file {0} has an unknown file type {1}.", + FileInfo.Name, FileType)); + } +#if DEBUG + Debug.WriteLine(string.Format( + "\tFileType: {0}", FileType)); +#endif + int clipIndex = + ((int)data[12] << 24) + + ((int)data[13] << 16) + + ((int)data[14] << 8) + + ((int)data[15]); + + int clipLength = + ((int)data[clipIndex] << 24) + + ((int)data[clipIndex + 1] << 16) + + ((int)data[clipIndex + 2] << 8) + + ((int)data[clipIndex + 3]); + + byte[] clipData = new byte[clipLength]; + Array.Copy(data, clipIndex + 4, clipData, 0, clipData.Length); + + int streamCount = clipData[8]; +#if DEBUG + Debug.WriteLine(string.Format( + "\tStreamCount: {0}", streamCount)); +#endif + int streamOffset = 10; + for (int streamIndex = 0; + streamIndex < streamCount; + streamIndex++) + { + TSStream stream = null; + + ushort PID = (ushort) + ((clipData[streamOffset] << 8) + + clipData[streamOffset + 1]); + + streamOffset += 2; + + TSStreamType streamType = (TSStreamType) + clipData[streamOffset + 1]; + switch (streamType) + { + case TSStreamType.MVC_VIDEO: + // TODO + break; + + case TSStreamType.AVC_VIDEO: + case TSStreamType.MPEG1_VIDEO: + case TSStreamType.MPEG2_VIDEO: + case TSStreamType.VC1_VIDEO: + { + TSVideoFormat videoFormat = (TSVideoFormat) + (clipData[streamOffset + 2] >> 4); + TSFrameRate frameRate = (TSFrameRate) + (clipData[streamOffset + 2] & 0xF); + TSAspectRatio aspectRatio = (TSAspectRatio) + (clipData[streamOffset + 3] >> 4); + + stream = new TSVideoStream(); + ((TSVideoStream)stream).VideoFormat = videoFormat; + ((TSVideoStream)stream).AspectRatio = aspectRatio; + ((TSVideoStream)stream).FrameRate = frameRate; +#if DEBUG + Debug.WriteLine(string.Format( + "\t{0} {1} {2} {3} {4}", + PID, + streamType, + videoFormat, + frameRate, + aspectRatio)); +#endif + } + break; + + case TSStreamType.AC3_AUDIO: + case TSStreamType.AC3_PLUS_AUDIO: + case TSStreamType.AC3_PLUS_SECONDARY_AUDIO: + case TSStreamType.AC3_TRUE_HD_AUDIO: + case TSStreamType.DTS_AUDIO: + case TSStreamType.DTS_HD_AUDIO: + case TSStreamType.DTS_HD_MASTER_AUDIO: + case TSStreamType.DTS_HD_SECONDARY_AUDIO: + case TSStreamType.LPCM_AUDIO: + case TSStreamType.MPEG1_AUDIO: + case TSStreamType.MPEG2_AUDIO: + { + byte[] languageBytes = new byte[3]; + Array.Copy(clipData, streamOffset + 3, + languageBytes, 0, languageBytes.Length); + string languageCode = + ASCIIEncoding.ASCII.GetString(languageBytes); + + TSChannelLayout channelLayout = (TSChannelLayout) + (clipData[streamOffset + 2] >> 4); + TSSampleRate sampleRate = (TSSampleRate) + (clipData[streamOffset + 2] & 0xF); + + stream = new TSAudioStream(); + ((TSAudioStream)stream).LanguageCode = languageCode; + ((TSAudioStream)stream).ChannelLayout = channelLayout; + ((TSAudioStream)stream).SampleRate = TSAudioStream.ConvertSampleRate(sampleRate); + ((TSAudioStream)stream).LanguageCode = languageCode; +#if DEBUG + Debug.WriteLine(string.Format( + "\t{0} {1} {2} {3} {4}", + PID, + streamType, + languageCode, + channelLayout, + sampleRate)); +#endif + } + break; + + case TSStreamType.INTERACTIVE_GRAPHICS: + case TSStreamType.PRESENTATION_GRAPHICS: + { + byte[] languageBytes = new byte[3]; + Array.Copy(clipData, streamOffset + 2, + languageBytes, 0, languageBytes.Length); + string languageCode = + ASCIIEncoding.ASCII.GetString(languageBytes); + + stream = new TSGraphicsStream(); + stream.LanguageCode = languageCode; +#if DEBUG + Debug.WriteLine(string.Format( + "\t{0} {1} {2}", + PID, + streamType, + languageCode)); +#endif + } + break; + + case TSStreamType.SUBTITLE: + { + byte[] languageBytes = new byte[3]; + Array.Copy(clipData, streamOffset + 3, + languageBytes, 0, languageBytes.Length); + string languageCode = + ASCIIEncoding.ASCII.GetString(languageBytes); +#if DEBUG + Debug.WriteLine(string.Format( + "\t{0} {1} {2}", + PID, + streamType, + languageCode)); +#endif + stream = new TSTextStream(); + stream.LanguageCode = languageCode; + } + break; + } + + if (stream != null) + { + stream.PID = PID; + stream.StreamType = streamType; + Streams.Add(PID, stream); + } + + streamOffset += clipData[streamOffset] + 1; + } + IsValid = true; + } + finally + { + if (fileReader != null) fileReader.Dispose(); + if (fileStream != null) fileStream.Dispose(); + } + } + } +} diff --git a/BDInfo/TSStreamFile.cs b/BDInfo/TSStreamFile.cs new file mode 100644 index 0000000000..86cefe8266 --- /dev/null +++ b/BDInfo/TSStreamFile.cs @@ -0,0 +1,1549 @@ +//============================================================================ +// BDInfo - Blu-ray Video and Audio Analysis Tool +// Copyright © 2010 Cinema Squid +// +// This library is free software; you can redistribute it and/or +// modify it under the terms of the GNU Lesser General Public +// License as published by the Free Software Foundation; either +// version 2.1 of the License, or (at your option) any later version. +// +// This library is distributed in the hope that it will be useful, +// but WITHOUT ANY WARRANTY; without even the implied warranty of +// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU +// Lesser General Public License for more details. +// +// You should have received a copy of the GNU Lesser General Public +// License along with this library; if not, write to the Free Software +// Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA +//============================================================================= + +#undef DEBUG +using System; +using System.Collections.Generic; +using System.IO; + +namespace BDInfo +{ + public class TSStreamState + { + public ulong TransferCount = 0; + + public string StreamTag = null; + + public ulong TotalPackets = 0; + public ulong WindowPackets = 0; + + public ulong TotalBytes = 0; + public ulong WindowBytes = 0; + + public long PeakTransferLength = 0; + public long PeakTransferRate = 0; + + public double TransferMarker = 0; + public double TransferInterval = 0; + + public TSStreamBuffer StreamBuffer = new TSStreamBuffer(); + + public uint Parse = 0; + public bool TransferState = false; + public int TransferLength = 0; + public int PacketLength = 0; + public byte PacketLengthParse = 0; + public byte PacketParse = 0; + + public byte PTSParse = 0; + public ulong PTS = 0; + public ulong PTSTemp = 0; + public ulong PTSLast = 0; + public ulong PTSPrev = 0; + public ulong PTSDiff = 0; + public ulong PTSCount = 0; + public ulong PTSTransfer = 0; + + public byte DTSParse = 0; + public ulong DTSTemp = 0; + public ulong DTSPrev = 0; + + public byte PESHeaderLength = 0; + public byte PESHeaderFlags = 0; +#if DEBUG + public byte PESHeaderIndex = 0; + public byte[] PESHeader = new byte[256 + 9]; +#endif + } + + public class TSPacketParser + { + public bool SyncState = false; + public byte TimeCodeParse = 4; + public byte PacketLength = 0; + public byte HeaderParse = 0; + + public uint TimeCode; + public byte TransportErrorIndicator; + public byte PayloadUnitStartIndicator; + public byte TransportPriority; + public ushort PID; + public byte TransportScramblingControl; + public byte AdaptionFieldControl; + + public bool AdaptionFieldState = false; + public byte AdaptionFieldParse = 0; + public byte AdaptionFieldLength = 0; + + public ushort PCRPID = 0xFFFF; + public byte PCRParse = 0; + public ulong PreviousPCR = 0; + public ulong PCR = 0; + public ulong PCRCount = 0; + public ulong PTSFirst = ulong.MaxValue; + public ulong PTSLast = ulong.MinValue; + public ulong PTSDiff = 0; + + public byte[] PAT = new byte[1024]; + public bool PATSectionStart = false; + public byte PATPointerField = 0; + public uint PATOffset = 0; + public byte PATSectionLengthParse = 0; + public ushort PATSectionLength = 0; + public uint PATSectionParse = 0; + public bool PATTransferState = false; + public byte PATSectionNumber = 0; + public byte PATLastSectionNumber = 0; + + public ushort TransportStreamId = 0xFFFF; + + public List PMTProgramDescriptors = new List(); + public ushort PMTPID = 0xFFFF; + public Dictionary PMT = new Dictionary(); + public bool PMTSectionStart = false; + public ushort PMTProgramInfoLength = 0; + public byte PMTProgramDescriptor = 0; + public byte PMTProgramDescriptorLengthParse = 0; + public byte PMTProgramDescriptorLength = 0; + public ushort PMTStreamInfoLength = 0; + public uint PMTStreamDescriptorLengthParse = 0; + public uint PMTStreamDescriptorLength = 0; + public byte PMTPointerField = 0; + public uint PMTOffset = 0; + public uint PMTSectionLengthParse = 0; + public ushort PMTSectionLength = 0; + public uint PMTSectionParse = 0; + public bool PMTTransferState = false; + public byte PMTSectionNumber = 0; + public byte PMTLastSectionNumber = 0; + + public byte PMTTemp = 0; + + public TSStream Stream = null; + public TSStreamState StreamState = null; + + public ulong TotalPackets = 0; + } + + public class TSStreamDiagnostics + { + public ulong Bytes = 0; + public ulong Packets = 0; + public double Marker = 0; + public double Interval = 0; + public string Tag = null; + } + + public class TSStreamFile + { + public FileInfo FileInfo = null; + public string Name = null; + public long Size = 0; + public double Length = 0; + + public TSInterleavedFile InterleavedFile = null; + + private Dictionary StreamStates = + new Dictionary(); + + public Dictionary Streams = + new Dictionary(); + + public Dictionary> StreamDiagnostics = + new Dictionary>(); + + private List Playlists = null; + + public TSStreamFile(FileInfo fileInfo) + { + FileInfo = fileInfo; + Name = fileInfo.Name.ToUpper(); + } + + public string DisplayName + { + get + { + if (BDInfoSettings.EnableSSIF && + InterleavedFile != null) + { + return InterleavedFile.Name; + } + return Name; + } + } + + private bool ScanStream( + TSStream stream, + TSStreamState streamState, + TSStreamBuffer buffer) + { + streamState.StreamTag = null; + + long bitrate = 0; + if (stream.IsAudioStream && + streamState.PTSTransfer > 0) + { + bitrate = (long)Math.Round( + (buffer.TransferLength * 8.0) / + ((double)streamState.PTSTransfer / 90000)); + + if (bitrate > streamState.PeakTransferRate) + { + streamState.PeakTransferRate = bitrate; + } + } + if (buffer.TransferLength > streamState.PeakTransferLength) + { + streamState.PeakTransferLength = buffer.TransferLength; + } + + buffer.BeginRead(); + switch (stream.StreamType) + { + case TSStreamType.MPEG2_VIDEO: + TSCodecMPEG2.Scan( + (TSVideoStream)stream, buffer, ref streamState.StreamTag); + break; + + case TSStreamType.AVC_VIDEO: + TSCodecAVC.Scan( + (TSVideoStream)stream, buffer, ref streamState.StreamTag); + break; + + case TSStreamType.MVC_VIDEO: + TSCodecMVC.Scan( + (TSVideoStream)stream, buffer, ref streamState.StreamTag); + break; + + case TSStreamType.VC1_VIDEO: + TSCodecVC1.Scan( + (TSVideoStream)stream, buffer, ref streamState.StreamTag); + break; + + case TSStreamType.AC3_AUDIO: + TSCodecAC3.Scan( + (TSAudioStream)stream, buffer, ref streamState.StreamTag); + break; + + case TSStreamType.AC3_PLUS_AUDIO: + case TSStreamType.AC3_PLUS_SECONDARY_AUDIO: + TSCodecAC3.Scan( + (TSAudioStream)stream, buffer, ref streamState.StreamTag); + break; + + case TSStreamType.AC3_TRUE_HD_AUDIO: + TSCodecTrueHD.Scan( + (TSAudioStream)stream, buffer, ref streamState.StreamTag); + break; + + case TSStreamType.LPCM_AUDIO: + TSCodecLPCM.Scan( + (TSAudioStream)stream, buffer, ref streamState.StreamTag); + break; + + case TSStreamType.DTS_AUDIO: + TSCodecDTS.Scan( + (TSAudioStream)stream, buffer, bitrate, ref streamState.StreamTag); + break; + + case TSStreamType.DTS_HD_AUDIO: + case TSStreamType.DTS_HD_MASTER_AUDIO: + case TSStreamType.DTS_HD_SECONDARY_AUDIO: + TSCodecDTSHD.Scan( + (TSAudioStream)stream, buffer, bitrate, ref streamState.StreamTag); + break; + + default: + stream.IsInitialized = true; + break; + } + buffer.EndRead(); + streamState.StreamBuffer.Reset(); + + bool isAVC = false; + bool isMVC = false; + foreach (TSStream finishedStream in Streams.Values) + { + if (!finishedStream.IsInitialized) + { + return false; + } + if (finishedStream.StreamType == TSStreamType.AVC_VIDEO) + { + isAVC = true; + } + if (finishedStream.StreamType == TSStreamType.MVC_VIDEO) + { + isMVC = true; + } + } + if (isMVC && !isAVC) + { + return false; + } + return true; + } + + private void UpdateStreamBitrates( + ushort PTSPID, + ulong PTS, + ulong PTSDiff) + { + if (Playlists == null) return; + + foreach (ushort PID in StreamStates.Keys) + { + if (Streams.ContainsKey(PID) && + Streams[PID].IsVideoStream && + PID != PTSPID) + { + continue; + } + if (StreamStates[PID].WindowPackets == 0) + { + continue; + } + UpdateStreamBitrate(PID, PTSPID, PTS, PTSDiff); + } + + foreach (TSPlaylistFile playlist in Playlists) + { + double packetSeconds = 0; + foreach (TSStreamClip clip in playlist.StreamClips) + { + if (clip.AngleIndex == 0) + { + packetSeconds += clip.PacketSeconds; + } + } + if (packetSeconds > 0) + { + foreach (TSStream playlistStream in playlist.SortedStreams) + { + if (playlistStream.IsVBR) + { + playlistStream.BitRate = (long)Math.Round( + ((playlistStream.PayloadBytes * 8.0) / packetSeconds)); + + if (playlistStream.StreamType == TSStreamType.AC3_TRUE_HD_AUDIO && + ((TSAudioStream)playlistStream).CoreStream != null) + { + playlistStream.BitRate -= + ((TSAudioStream)playlistStream).CoreStream.BitRate; + } + } + } + } + } + } + + private void UpdateStreamBitrate( + ushort PID, + ushort PTSPID, + ulong PTS, + ulong PTSDiff) + { + if (Playlists == null) return; + + TSStreamState streamState = StreamStates[PID]; + double streamTime = (double)PTS / 90000; + double streamInterval = (double)PTSDiff / 90000; + double streamOffset = streamTime + streamInterval; + + foreach (TSPlaylistFile playlist in Playlists) + { + foreach (TSStreamClip clip in playlist.StreamClips) + { + if (clip.Name != this.Name) continue; + + if (streamTime == 0 || + (streamTime >= clip.TimeIn && + streamTime <= clip.TimeOut)) + { + clip.PayloadBytes += streamState.WindowBytes; + clip.PacketCount += streamState.WindowPackets; + + if (streamOffset > clip.TimeIn && + streamOffset - clip.TimeIn > clip.PacketSeconds) + { + clip.PacketSeconds = streamOffset - clip.TimeIn; + } + + Dictionary playlistStreams = playlist.Streams; + if (clip.AngleIndex > 0 && + clip.AngleIndex < playlist.AngleStreams.Count + 1) + { + playlistStreams = playlist.AngleStreams[clip.AngleIndex - 1]; + } + if (playlistStreams.ContainsKey(PID)) + { + TSStream stream = playlistStreams[PID]; + + stream.PayloadBytes += streamState.WindowBytes; + stream.PacketCount += streamState.WindowPackets; + + if (stream.IsVideoStream) + { + stream.PacketSeconds += streamInterval; + + stream.ActiveBitRate = (long)Math.Round( + ((stream.PayloadBytes * 8.0) / + stream.PacketSeconds)); + } + + if (stream.StreamType == TSStreamType.AC3_TRUE_HD_AUDIO && + ((TSAudioStream)stream).CoreStream != null) + { + stream.ActiveBitRate -= + ((TSAudioStream)stream).CoreStream.BitRate; + } + } + } + } + } + + if (Streams.ContainsKey(PID)) + { + TSStream stream = Streams[PID]; + stream.PayloadBytes += streamState.WindowBytes; + stream.PacketCount += streamState.WindowPackets; + + if (stream.IsVideoStream) + { + TSStreamDiagnostics diag = new TSStreamDiagnostics(); + diag.Marker = (double)PTS / 90000; + diag.Interval = (double)PTSDiff / 90000; + diag.Bytes = streamState.WindowBytes; + diag.Packets = streamState.WindowPackets; + diag.Tag = streamState.StreamTag; + StreamDiagnostics[PID].Add(diag); + + stream.PacketSeconds += streamInterval; + } + } + streamState.WindowPackets = 0; + streamState.WindowBytes = 0; + } + + public void Scan(List playlists, bool isFullScan) + { + if (playlists == null || playlists.Count == 0) + { + return; + } + + Playlists = playlists; + int dataSize = 16384; + FileStream fileStream = null; + try + { + string fileName; + if (BDInfoSettings.EnableSSIF && + InterleavedFile != null) + { + fileName = InterleavedFile.FileInfo.FullName; + } + else + { + fileName = FileInfo.FullName; + } + fileStream = new FileStream( + fileName, + FileMode.Open, + FileAccess.Read, + FileShare.Read, + dataSize, false); + + Size = 0; + Length = 0; + + Streams.Clear(); + StreamStates.Clear(); + StreamDiagnostics.Clear(); + + TSPacketParser parser = + new TSPacketParser(); + + long fileLength = (uint)fileStream.Length; + byte[] buffer = new byte[dataSize]; + int bufferLength = 0; + while ((bufferLength = + fileStream.Read(buffer, 0, buffer.Length)) > 0) + { + int offset = 0; + for (int i = 0; i < bufferLength; i++) + { + if (parser.SyncState == false) + { + if (parser.TimeCodeParse > 0) + { + parser.TimeCodeParse--; + switch (parser.TimeCodeParse) + { + case 3: + parser.TimeCode = 0; + parser.TimeCode |= + ((uint)buffer[i] & 0x3F) << 24; + break; + case 2: + parser.TimeCode |= + ((uint)buffer[i] & 0xFF) << 16; + break; + case 1: + parser.TimeCode |= + ((uint)buffer[i] & 0xFF) << 8; + break; + case 0: + parser.TimeCode |= + ((uint)buffer[i] & 0xFF); + break; + } + } + else if (buffer[i] == 0x47) + { + parser.SyncState = true; + parser.PacketLength = 187; + parser.TimeCodeParse = 4; + parser.HeaderParse = 3; + } + } + else if (parser.HeaderParse > 0) + { + parser.PacketLength--; + parser.HeaderParse--; + + switch (parser.HeaderParse) + { + case 2: + { + parser.TransportErrorIndicator = + (byte)((buffer[i] >> 7) & 0x1); + parser.PayloadUnitStartIndicator = + (byte)((buffer[i] >> 6) & 0x1); + parser.TransportPriority = + (byte)((buffer[i] >> 5) & 0x1); + parser.PID = + (ushort)((buffer[i] & 0x1f) << 8); + } + break; + + case 1: + { + parser.PID |= (ushort)buffer[i]; + if (Streams.ContainsKey(parser.PID)) + { + parser.Stream = Streams[parser.PID]; + } + else + { + parser.Stream = null; + } + if (!StreamStates.ContainsKey(parser.PID)) + { + StreamStates[parser.PID] = new TSStreamState(); + } + parser.StreamState = StreamStates[parser.PID]; + parser.StreamState.TotalPackets++; + parser.StreamState.WindowPackets++; + parser.TotalPackets++; + } + break; + + case 0: + { + parser.TransportScramblingControl = + (byte)((buffer[i] >> 6) & 0x3); + parser.AdaptionFieldControl = + (byte)((buffer[i] >> 4) & 0x3); + + if ((parser.AdaptionFieldControl & 0x2) == 0x2) + { + parser.AdaptionFieldState = true; + } + if (parser.PayloadUnitStartIndicator == 1) + { + if (parser.PID == 0) + { + parser.PATSectionStart = true; + } + else if (parser.PID == parser.PMTPID) + { + parser.PMTSectionStart = true; + } + else if (parser.StreamState != null && + parser.StreamState.TransferState) + { + parser.StreamState.TransferState = false; + parser.StreamState.TransferCount++; + + bool isFinished = ScanStream( + parser.Stream, + parser.StreamState, + parser.StreamState.StreamBuffer); + + if (!isFullScan && isFinished) + { + return; + } + } + } + } + break; + } + } + else if (parser.AdaptionFieldState) + { + parser.PacketLength--; + parser.AdaptionFieldParse = buffer[i]; + parser.AdaptionFieldLength = buffer[i]; + parser.AdaptionFieldState = false; + } + else if (parser.AdaptionFieldParse > 0) + { + parser.PacketLength--; + parser.AdaptionFieldParse--; + if ((parser.AdaptionFieldLength - parser.AdaptionFieldParse) == 1) + { + if ((buffer[i] & 0x10) == 0x10) + { + parser.PCRParse = 6; + parser.PCR = 0; + } + } + else if (parser.PCRParse > 0) + { + parser.PCRParse--; + parser.PCR = (parser.PCR << 8) + (ulong)buffer[i]; + if (parser.PCRParse == 0) + { + parser.PreviousPCR = parser.PCR; + parser.PCR = (parser.PCR & 0x1FF) + + ((parser.PCR >> 15) * 300); + } + parser.PCRCount++; + } + if (parser.PacketLength == 0) + { + parser.SyncState = false; + } + } + else if (parser.PID == 0) + { + if (parser.PATTransferState) + { + if ((bufferLength - i) > parser.PATSectionLength) + { + offset = parser.PATSectionLength; + } + else + { + offset = (bufferLength - i); + } + if (parser.PacketLength <= offset) + { + offset = parser.PacketLength; + } + + for (int k = 0; k < offset; k++) + { + parser.PAT[parser.PATOffset++] = buffer[i++]; + parser.PATSectionLength--; + parser.PacketLength--; + } --i; + + if (parser.PATSectionLength == 0) + { + parser.PATTransferState = false; + if (parser.PATSectionNumber == parser.PATLastSectionNumber) + { + for (int k = 0; k < (parser.PATOffset - 4); k += 4) + { + uint programNumber = (uint) + ((parser.PAT[k] << 8) + + parser.PAT[k + 1]); + + ushort programPID = (ushort) + (((parser.PAT[k + 2] & 0x1F) << 8) + + parser.PAT[k + 3]); + + if (programNumber == 1) + { + parser.PMTPID = programPID; + } + } + } + } + } + else + { + --parser.PacketLength; + if (parser.PATSectionStart) + { + parser.PATPointerField = buffer[i]; + if (parser.PATPointerField == 0) + { + parser.PATSectionLengthParse = 3; + } + parser.PATSectionStart = false; + } + else if (parser.PATPointerField > 0) + { + --parser.PATPointerField; + if (parser.PATPointerField == 0) + { + parser.PATSectionLengthParse = 3; + } + } + else if (parser.PATSectionLengthParse > 0) + { + --parser.PATSectionLengthParse; + switch (parser.PATSectionLengthParse) + { + case 2: + break; + case 1: + parser.PATSectionLength = (ushort) + ((buffer[i] & 0xF) << 8); + break; + case 0: + parser.PATSectionLength |= buffer[i]; + if (parser.PATSectionLength > 1021) + { + parser.PATSectionLength = 0; + } + else + { + parser.PATSectionParse = 5; + } + break; + } + } + else if (parser.PATSectionParse > 0) + { + --parser.PATSectionLength; + --parser.PATSectionParse; + + switch (parser.PATSectionParse) + { + case 4: + parser.TransportStreamId = (ushort) + (buffer[i] << 8); + break; + case 3: + parser.TransportStreamId |= buffer[i]; + break; + case 2: + break; + case 1: + parser.PATSectionNumber = buffer[i]; + if (parser.PATSectionNumber == 0) + { + parser.PATOffset = 0; + } + break; + case 0: + parser.PATLastSectionNumber = buffer[i]; + parser.PATTransferState = true; + break; + } + } + } + if (parser.PacketLength == 0) + { + parser.SyncState = false; + } + } + else if (parser.PID == parser.PMTPID) + { + if (parser.PMTTransferState) + { + if ((bufferLength - i) >= parser.PMTSectionLength) + { + offset = parser.PMTSectionLength; + } + else + { + offset = (bufferLength - i); + } + if (parser.PacketLength <= offset) + { + offset = parser.PacketLength; + } + if (!parser.PMT.ContainsKey(parser.PID)) + { + parser.PMT[parser.PID] = new byte[1024]; + } + + byte[] PMT = parser.PMT[parser.PID]; + for (int k = 0; k < offset; k++) + { + PMT[parser.PMTOffset++] = buffer[i++]; + --parser.PMTSectionLength; + --parser.PacketLength; + } --i; + + if (parser.PMTSectionLength == 0) + { + parser.PMTTransferState = false; + if (parser.PMTSectionNumber == parser.PMTLastSectionNumber) + { + //Console.WriteLine("PMT Start: " + parser.PMTTemp); + try + { + for (int k = 0; k < (parser.PMTOffset - 4); k += 5) + { + byte streamType = PMT[k]; + + ushort streamPID = (ushort) + (((PMT[k + 1] & 0x1F) << 8) + + PMT[k + 2]); + + ushort streamInfoLength = (ushort) + (((PMT[k + 3] & 0xF) << 8) + + PMT[k + 4]); + + /* + if (streamInfoLength == 2) + { + // TODO: Cleanup + //streamInfoLength = 0; + } + + Console.WriteLine(string.Format( + "Type: {0} PID: {1} Length: {2}", + streamType, streamPID, streamInfoLength)); + */ + + if (!Streams.ContainsKey(streamPID)) + { + List streamDescriptors = + new List(); + + /* + * TODO: Getting bad streamInfoLength + if (streamInfoLength > 0) + { + for (int d = 0; d < streamInfoLength; d++) + { + byte name = PMT[k + d + 5]; + byte length = PMT[k + d + 6]; + TSDescriptor descriptor = + new TSDescriptor(name, length); + for (int v = 0; v < length; v++) + { + descriptor.Value[v] = + PMT[k + d + v + 7]; + } + streamDescriptors.Add(descriptor); + d += (length + 1); + } + } + */ + CreateStream(streamPID, streamType, streamDescriptors); + } + k += streamInfoLength; + } + } + catch (Exception ex) + { + // TODO + //Console.WriteLine(ex.Message); + } + } + } + } + else + { + --parser.PacketLength; + if (parser.PMTSectionStart) + { + parser.PMTPointerField = buffer[i]; + if (parser.PMTPointerField == 0) + { + parser.PMTSectionLengthParse = 3; + } + parser.PMTSectionStart = false; + } + else if (parser.PMTPointerField > 0) + { + --parser.PMTPointerField; + if (parser.PMTPointerField == 0) + { + parser.PMTSectionLengthParse = 3; + } + } + else if (parser.PMTSectionLengthParse > 0) + { + --parser.PMTSectionLengthParse; + switch (parser.PMTSectionLengthParse) + { + case 2: + if (buffer[i] != 0x2) + { + parser.PMTSectionLengthParse = 0; + } + break; + case 1: + parser.PMTSectionLength = (ushort) + ((buffer[i] & 0xF) << 8); + break; + case 0: + parser.PMTSectionLength |= buffer[i]; + if (parser.PMTSectionLength > 1021) + { + parser.PMTSectionLength = 0; + } + else + { + parser.PMTSectionParse = 9; + } + break; + } + } + else if (parser.PMTSectionParse > 0) + { + --parser.PMTSectionLength; + --parser.PMTSectionParse; + + switch (parser.PMTSectionParse) + { + case 8: + case 7: + break; + case 6: + parser.PMTTemp = buffer[i]; + break; + case 5: + parser.PMTSectionNumber = buffer[i]; + if (parser.PMTSectionNumber == 0) + { + parser.PMTOffset = 0; + } + break; + case 4: + parser.PMTLastSectionNumber = buffer[i]; + break; + case 3: + parser.PCRPID = (ushort) + ((buffer[i] & 0x1F) << 8); + break; + case 2: + parser.PCRPID |= buffer[i]; + break; + case 1: + parser.PMTProgramInfoLength = (ushort) + ((buffer[i] & 0xF) << 8); + break; + case 0: + parser.PMTProgramInfoLength |= buffer[i]; + if (parser.PMTProgramInfoLength == 0) + { + parser.PMTTransferState = true; + } + else + { + parser.PMTProgramDescriptorLengthParse = 2; + } + break; + } + } + else if (parser.PMTProgramInfoLength > 0) + { + --parser.PMTSectionLength; + --parser.PMTProgramInfoLength; + + if (parser.PMTProgramDescriptorLengthParse > 0) + { + --parser.PMTProgramDescriptorLengthParse; + switch (parser.PMTProgramDescriptorLengthParse) + { + case 1: + parser.PMTProgramDescriptor = buffer[i]; + break; + case 0: + parser.PMTProgramDescriptorLength = buffer[i]; + parser.PMTProgramDescriptors.Add( + new TSDescriptor( + parser.PMTProgramDescriptor, + parser.PMTProgramDescriptorLength)); + break; + } + } + else if (parser.PMTProgramDescriptorLength > 0) + { + --parser.PMTProgramDescriptorLength; + + TSDescriptor descriptor = parser.PMTProgramDescriptors[ + parser.PMTProgramDescriptors.Count - 1]; + + int valueIndex = + descriptor.Value.Length - + parser.PMTProgramDescriptorLength - 1; + + descriptor.Value[valueIndex] = buffer[i]; + + if (parser.PMTProgramDescriptorLength == 0 && + parser.PMTProgramInfoLength > 0) + { + parser.PMTProgramDescriptorLengthParse = 2; + } + } + if (parser.PMTProgramInfoLength == 0) + { + parser.PMTTransferState = true; + } + } + } + if (parser.PacketLength == 0) + { + parser.SyncState = false; + } + } + else if (parser.Stream != null && + parser.StreamState != null && + parser.TransportScramblingControl == 0) + { + TSStream stream = parser.Stream; + TSStreamState streamState = parser.StreamState; + + streamState.Parse = + (streamState.Parse << 8) + buffer[i]; + + if (streamState.TransferState) + { + if ((bufferLength - i) >= streamState.PacketLength && + streamState.PacketLength > 0) + { + offset = streamState.PacketLength; + } + else + { + offset = (bufferLength - i); + } + if (parser.PacketLength <= offset) + { + offset = parser.PacketLength; + } + streamState.TransferLength = offset; + + if (!stream.IsInitialized || + stream.IsVideoStream) + { + streamState.StreamBuffer.Add( + buffer, i, offset); + } + else + { + streamState.StreamBuffer.TransferLength += offset; + } + + i += (int)(streamState.TransferLength - 1); + streamState.PacketLength -= streamState.TransferLength; + parser.PacketLength -= (byte)streamState.TransferLength; + + streamState.TotalBytes += (ulong)streamState.TransferLength; + streamState.WindowBytes += (ulong)streamState.TransferLength; + + if (streamState.PacketLength == 0) + { + streamState.TransferState = false; + streamState.TransferCount++; + bool isFinished = ScanStream( + stream, + streamState, + streamState.StreamBuffer); + + if (!isFullScan && isFinished) + { + return; + } + } + } + else + { + --parser.PacketLength; + + bool headerFound = false; + if (stream.IsVideoStream && + streamState.Parse == 0x000001FD) + { + headerFound = true; + } + if (stream.IsVideoStream && + streamState.Parse >= 0x000001E0 && + streamState.Parse <= 0x000001EF) + { + headerFound = true; + } + if (stream.IsAudioStream && + streamState.Parse == 0x000001BD) + { + headerFound = true; + } + if (stream.IsAudioStream && + (streamState.Parse == 0x000001FA || + streamState.Parse == 0x000001FD)) + { + headerFound = true; + } + + if (!stream.IsVideoStream && + !stream.IsAudioStream && + (streamState.Parse == 0x000001FA || + streamState.Parse == 0x000001FD || + streamState.Parse == 0x000001BD || + (streamState.Parse >= 0x000001E0 && + streamState.Parse <= 0x000001EF))) + { + headerFound = true; + } + + if (headerFound) + { + streamState.PacketLengthParse = 2; +#if DEBUG + streamState.PESHeaderIndex = 0; + streamState.PESHeader[streamState.PESHeaderIndex++] = + (byte)((streamState.Parse >> 24) & 0xFF); + streamState.PESHeader[streamState.PESHeaderIndex++] = + (byte)((streamState.Parse >> 16) & 0xFF); + streamState.PESHeader[streamState.PESHeaderIndex++] = + (byte)((streamState.Parse >> 8) & 0xFF); + streamState.PESHeader[streamState.PESHeaderIndex++] = + (byte)(streamState.Parse & 0xFF); +#endif + } + else if (streamState.PacketLengthParse > 0) + { + --streamState.PacketLengthParse; + switch (streamState.PacketLengthParse) + { + case 1: +#if DEBUG + streamState.PESHeader[streamState.PESHeaderIndex++] = + (byte)(streamState.Parse & 0xFF); +#endif + break; + + case 0: + streamState.PacketLength = + (int)(streamState.Parse & 0xFFFF); + streamState.PacketParse = 3; +#if DEBUG + streamState.PESHeader[streamState.PESHeaderIndex++] = + (byte)(streamState.Parse & 0xFF); +#endif + break; + } + } + else if (streamState.PacketParse > 0) + { + --streamState.PacketLength; + --streamState.PacketParse; + + switch (streamState.PacketParse) + { + case 2: +#if DEBUG + streamState.PESHeader[streamState.PESHeaderIndex++] = + (byte)(streamState.Parse & 0xFF); +#endif + break; + + case 1: + streamState.PESHeaderFlags = + (byte)(streamState.Parse & 0xFF); +#if DEBUG + streamState.PESHeader[streamState.PESHeaderIndex++] = + (byte)(streamState.Parse & 0xFF); +#endif + break; + + case 0: + streamState.PESHeaderLength = + (byte)(streamState.Parse & 0xFF); +#if DEBUG + streamState.PESHeader[streamState.PESHeaderIndex++] = + (byte)(streamState.Parse & 0xFF); +#endif + if ((streamState.PESHeaderFlags & 0xC0) == 0x80) + { + streamState.PTSParse = 5; + } + else if ((streamState.PESHeaderFlags & 0xC0) == 0xC0) + { + streamState.DTSParse = 10; + } + if (streamState.PESHeaderLength == 0) + { + streamState.TransferState = true; + } + break; + } + } + else if (streamState.PTSParse > 0) + { + --streamState.PacketLength; + --streamState.PESHeaderLength; + --streamState.PTSParse; + + switch (streamState.PTSParse) + { + case 4: + streamState.PTSTemp = + ((streamState.Parse & 0xE) << 29); +#if DEBUG + streamState.PESHeader[streamState.PESHeaderIndex++] = + (byte)(streamState.Parse & 0xff); +#endif + break; + + case 3: + streamState.PTSTemp |= + ((streamState.Parse & 0xFF) << 22); +#if DEBUG + streamState.PESHeader[streamState.PESHeaderIndex++] = + (byte)(streamState.Parse & 0xFF); +#endif + break; + + case 2: + streamState.PTSTemp |= + ((streamState.Parse & 0xFE) << 14); +#if DEBUG + streamState.PESHeader[streamState.PESHeaderIndex++] = + (byte)(streamState.Parse & 0xFF); +#endif + break; + + case 1: + streamState.PTSTemp |= + ((streamState.Parse & 0xFF) << 7); +#if DEBUG + streamState.PESHeader[streamState.PESHeaderIndex++] = + (byte)(streamState.Parse & 0xFF); +#endif + break; + + case 0: + streamState.PTSTemp |= + ((streamState.Parse & 0xFE) >> 1); +#if DEBUG + streamState.PESHeader[streamState.PESHeaderIndex++] = + (byte)(streamState.Parse & 0xff); +#endif + streamState.PTS = streamState.PTSTemp; + + if (streamState.PTS > streamState.PTSLast) + { + if (streamState.PTSLast > 0) + { + streamState.PTSTransfer = (streamState.PTS - streamState.PTSLast); + } + streamState.PTSLast = streamState.PTS; + } + + streamState.PTSDiff = streamState.PTS - streamState.DTSPrev; + + if (streamState.PTSCount > 0 && + stream.IsVideoStream) + { + UpdateStreamBitrates(stream.PID, streamState.PTS, streamState.PTSDiff); + if (streamState.DTSTemp < parser.PTSFirst) + { + parser.PTSFirst = streamState.DTSTemp; + } + if (streamState.DTSTemp > parser.PTSLast) + { + parser.PTSLast = streamState.DTSTemp; + } + Length = (double)(parser.PTSLast - parser.PTSFirst) / 90000; + } + + streamState.DTSPrev = streamState.PTS; + streamState.PTSCount++; + if (streamState.PESHeaderLength == 0) + { + streamState.TransferState = true; + } + break; + } + } + else if (streamState.DTSParse > 0) + { + --streamState.PacketLength; + --streamState.PESHeaderLength; + --streamState.DTSParse; + + switch (streamState.DTSParse) + { + case 9: + streamState.PTSTemp = + ((streamState.Parse & 0xE) << 29); +#if DEBUG + streamState.PESHeader[streamState.PESHeaderIndex++] = + (byte)(streamState.Parse & 0xFF); +#endif + break; + + case 8: + streamState.PTSTemp |= + ((streamState.Parse & 0xFF) << 22); +#if DEBUG + streamState.PESHeader[streamState.PESHeaderIndex++] = + (byte)(streamState.Parse & 0xFF); +#endif + break; + + case 7: + streamState.PTSTemp |= + ((streamState.Parse & 0xFE) << 14); +#if DEBUG + streamState.PESHeader[streamState.PESHeaderIndex++] = + (byte)(streamState.Parse & 0xff); +#endif + break; + + case 6: + streamState.PTSTemp |= + ((streamState.Parse & 0xFF) << 7); +#if DEBUG + streamState.PESHeader[streamState.PESHeaderIndex++] = + (byte)(streamState.Parse & 0xFF); +#endif + break; + + case 5: + streamState.PTSTemp |= + ((streamState.Parse & 0xFE) >> 1); +#if DEBUG + streamState.PESHeader[streamState.PESHeaderIndex++] = + (byte)(streamState.Parse & 0xff); +#endif + streamState.PTS = streamState.PTSTemp; + if (streamState.PTS > streamState.PTSLast) + { + streamState.PTSLast = streamState.PTS; + } + break; + + case 4: + streamState.DTSTemp = + ((streamState.Parse & 0xE) << 29); +#if DEBUG + streamState.PESHeader[streamState.PESHeaderIndex++] = + (byte)(streamState.Parse & 0xff); +#endif + break; + + case 3: + streamState.DTSTemp |= + ((streamState.Parse & 0xFF) << 22); +#if DEBUG + streamState.PESHeader[streamState.PESHeaderIndex++] = + (byte)(streamState.Parse & 0xff); +#endif + break; + + case 2: + streamState.DTSTemp |= + ((streamState.Parse & 0xFE) << 14); +#if DEBUG + streamState.PESHeader[streamState.PESHeaderIndex++] = + (byte)(streamState.Parse & 0xff); +#endif + break; + + case 1: + streamState.DTSTemp |= + ((streamState.Parse & 0xFF) << 7); +#if DEBUG + streamState.PESHeader[streamState.PESHeaderIndex++] = + (byte)(streamState.Parse & 0xFF); +#endif + break; + + case 0: + streamState.DTSTemp |= + ((streamState.Parse & 0xFE) >> 1); +#if DEBUG + streamState.PESHeader[streamState.PESHeaderIndex++] = + (byte)(streamState.Parse & 0xff); +#endif + streamState.PTSDiff = streamState.DTSTemp - streamState.DTSPrev; + + if (streamState.PTSCount > 0 && + stream.IsVideoStream) + { + UpdateStreamBitrates(stream.PID, streamState.DTSTemp, streamState.PTSDiff); + if (streamState.DTSTemp < parser.PTSFirst) + { + parser.PTSFirst = streamState.DTSTemp; + } + if (streamState.DTSTemp > parser.PTSLast) + { + parser.PTSLast = streamState.DTSTemp; + } + Length = (double)(parser.PTSLast - parser.PTSFirst) / 90000; + } + streamState.DTSPrev = streamState.DTSTemp; + streamState.PTSCount++; + if (streamState.PESHeaderLength == 0) + { + streamState.TransferState = true; + } + break; + } + } + else if (streamState.PESHeaderLength > 0) + { + --streamState.PacketLength; + --streamState.PESHeaderLength; +#if DEBUG + streamState.PESHeader[streamState.PESHeaderIndex++] = + (byte)(streamState.Parse & 0xFF); +#endif + if (streamState.PESHeaderLength == 0) + { + streamState.TransferState = true; + } + } + } + if (parser.PacketLength == 0) + { + parser.SyncState = false; + } + } + else + { + parser.PacketLength--; + if ((bufferLength - i) >= parser.PacketLength) + { + i = i + parser.PacketLength; + parser.PacketLength = 0; + } + else + { + parser.PacketLength -= (byte)((bufferLength - i) + 1); + i = bufferLength; + } + if (parser.PacketLength == 0) + { + parser.SyncState = false; + } + } + } + Size += bufferLength; + } + + ulong PTSLast = 0; + ulong PTSDiff = 0; + foreach (TSStream stream in Streams.Values) + { + if (!stream.IsVideoStream) continue; + + if (StreamStates.ContainsKey(stream.PID) && + StreamStates[stream.PID].PTSLast > PTSLast) + { + PTSLast = StreamStates[stream.PID].PTSLast; + PTSDiff = PTSLast - StreamStates[stream.PID].DTSPrev; + } + UpdateStreamBitrates(stream.PID, PTSLast, PTSDiff); + } + } + finally + { + if (fileStream != null) + { + fileStream.Dispose(); + } + } + } + + private TSStream CreateStream( + ushort streamPID, + byte streamType, + List streamDescriptors) + { + TSStream stream = null; + + switch ((TSStreamType)streamType) + { + case TSStreamType.MVC_VIDEO: + case TSStreamType.AVC_VIDEO: + case TSStreamType.MPEG1_VIDEO: + case TSStreamType.MPEG2_VIDEO: + case TSStreamType.VC1_VIDEO: + { + stream = new TSVideoStream(); + } + break; + + case TSStreamType.AC3_AUDIO: + case TSStreamType.AC3_PLUS_AUDIO: + case TSStreamType.AC3_PLUS_SECONDARY_AUDIO: + case TSStreamType.AC3_TRUE_HD_AUDIO: + case TSStreamType.DTS_AUDIO: + case TSStreamType.DTS_HD_AUDIO: + case TSStreamType.DTS_HD_MASTER_AUDIO: + case TSStreamType.DTS_HD_SECONDARY_AUDIO: + case TSStreamType.LPCM_AUDIO: + case TSStreamType.MPEG1_AUDIO: + case TSStreamType.MPEG2_AUDIO: + { + stream = new TSAudioStream(); + } + break; + + case TSStreamType.INTERACTIVE_GRAPHICS: + case TSStreamType.PRESENTATION_GRAPHICS: + { + stream = new TSGraphicsStream(); + } + break; + + case TSStreamType.SUBTITLE: + { + stream = new TSTextStream(); + } + break; + + default: + break; + } + + if (stream != null && + !Streams.ContainsKey(streamPID)) + { + stream.PID = streamPID; + stream.StreamType = (TSStreamType)streamType; + stream.Descriptors = streamDescriptors; + Streams[stream.PID] = stream; + } + if (!StreamDiagnostics.ContainsKey(streamPID)) + { + StreamDiagnostics[streamPID] = + new List(); + } + + return stream; + } + } +} diff --git a/BDInfo/project.json b/BDInfo/project.json new file mode 100644 index 0000000000..3d0dd3227e --- /dev/null +++ b/BDInfo/project.json @@ -0,0 +1,16 @@ +{ + "supports": { + "net46.app": {}, + "uwp.10.0.app": {}, + "dnxcore50.app": {} + }, + "dependencies": { + "Microsoft.NETCore": "5.0.0", + "Microsoft.NETCore.Portable.Compatibility": "1.0.0" + }, + "frameworks": { + "dotnet": { + "imports": "portable-net452+win81" + } + } +} \ No newline at end of file diff --git a/BDInfo/project.lock.json b/BDInfo/project.lock.json new file mode 100644 index 0000000000..3c12d4d88f --- /dev/null +++ b/BDInfo/project.lock.json @@ -0,0 +1,18472 @@ +{ + "locked": false, + "version": 2, + "targets": { + ".NETFramework,Version=v4.6": { + "Microsoft.CSharp/4.0.0": { + "type": "package", + "frameworkAssemblies": [ + "Microsoft.CSharp" + ], + "compile": { + "ref/net45/_._": {} + }, + "runtime": { + "lib/net45/_._": {} + } + }, + "Microsoft.NETCore/5.0.0": { + "type": "package", + "dependencies": { + "Microsoft.CSharp": "4.0.0", + "Microsoft.NETCore.Targets": "1.0.0", + "Microsoft.VisualBasic": "10.0.0", + "System.AppContext": "4.0.0", + "System.Collections": "4.0.10", + "System.Collections.Concurrent": "4.0.10", + "System.Collections.Immutable": "1.1.37", + "System.ComponentModel": "4.0.0", + "System.ComponentModel.Annotations": "4.0.10", + "System.Diagnostics.Debug": "4.0.10", + "System.Diagnostics.Tools": "4.0.0", + "System.Diagnostics.Tracing": "4.0.20", + "System.Dynamic.Runtime": "4.0.10", + "System.Globalization": "4.0.10", + "System.Globalization.Calendars": "4.0.0", + "System.Globalization.Extensions": "4.0.0", + "System.IO": "4.0.10", + "System.IO.Compression": "4.0.0", + "System.IO.Compression.ZipFile": "4.0.0", + "System.IO.FileSystem": "4.0.0", + "System.IO.FileSystem.Primitives": "4.0.0", + "System.IO.UnmanagedMemoryStream": "4.0.0", + "System.Linq": "4.0.0", + "System.Linq.Expressions": "4.0.10", + "System.Linq.Parallel": "4.0.0", + "System.Linq.Queryable": "4.0.0", + "System.Net.Http": "4.0.0", + "System.Net.NetworkInformation": "4.0.0", + "System.Net.Primitives": "4.0.10", + "System.Numerics.Vectors": "4.1.0", + "System.ObjectModel": "4.0.10", + "System.Reflection": "4.0.10", + "System.Reflection.DispatchProxy": "4.0.0", + "System.Reflection.Extensions": "4.0.0", + "System.Reflection.Metadata": "1.0.22", + "System.Reflection.Primitives": "4.0.0", + "System.Reflection.TypeExtensions": "4.0.0", + "System.Resources.ResourceManager": "4.0.0", + "System.Runtime": "4.0.20", + "System.Runtime.Extensions": "4.0.10", + "System.Runtime.Handles": "4.0.0", + "System.Runtime.InteropServices": "4.0.20", + "System.Runtime.Numerics": "4.0.0", + "System.Security.Claims": "4.0.0", + "System.Security.Principal": "4.0.0", + "System.Text.Encoding": "4.0.10", + "System.Text.Encoding.Extensions": "4.0.10", + "System.Text.RegularExpressions": "4.0.10", + "System.Threading": "4.0.10", + "System.Threading.Tasks": "4.0.10", + "System.Threading.Tasks.Dataflow": "4.5.25", + "System.Threading.Tasks.Parallel": "4.0.0", + "System.Threading.Timer": "4.0.0", + "System.Xml.ReaderWriter": "4.0.10", + "System.Xml.XDocument": "4.0.10" + } + }, + "Microsoft.NETCore.Platforms/1.0.0": { + "type": "package" + }, + "Microsoft.NETCore.Portable.Compatibility/1.0.0": { + "type": "package", + "compile": { + "ref/net45/_._": {} + }, + "runtime": { + "lib/net45/_._": {} + } + }, + "Microsoft.NETCore.Targets/1.0.0": { + "type": "package", + "dependencies": { + "Microsoft.NETCore.Platforms": "1.0.0", + "Microsoft.NETCore.Targets.NETFramework": "4.6.0" + } + }, + "Microsoft.NETCore.Targets.NETFramework/4.6.0": { + "type": "package" + }, + "Microsoft.VisualBasic/10.0.0": { + "type": "package", + "frameworkAssemblies": [ + "Microsoft.VisualBasic" + ], + "compile": { + "ref/net45/_._": {} + }, + "runtime": { + "lib/net45/_._": {} + } + }, + "System.AppContext/4.0.0": { + "type": "package", + "dependencies": { + "System.Runtime": "4.0.0" + }, + "frameworkAssemblies": [ + "mscorlib" + ], + "compile": { + "ref/net46/System.AppContext.dll": {} + }, + "runtime": { + "lib/net46/System.AppContext.dll": {} + } + }, + "System.Collections/4.0.10": { + "type": "package", + "compile": { + "ref/net46/_._": {} + }, + "runtime": { + "lib/net46/_._": {} + } + }, + "System.Collections.Concurrent/4.0.10": { + "type": "package", + "compile": { + "ref/net46/_._": {} + }, + "runtime": { + "lib/net46/_._": {} + } + }, + "System.Collections.Immutable/1.1.37": { + "type": "package", + "dependencies": { + "System.Collections": "4.0.0", + "System.Diagnostics.Debug": "4.0.0", + "System.Globalization": "4.0.0", + "System.Linq": "4.0.0", + "System.Resources.ResourceManager": "4.0.0", + "System.Runtime": "4.0.0", + "System.Runtime.Extensions": "4.0.0", + "System.Threading": "4.0.0" + }, + "compile": { + "lib/dotnet/System.Collections.Immutable.dll": {} + }, + "runtime": { + "lib/dotnet/System.Collections.Immutable.dll": {} + } + }, + "System.ComponentModel/4.0.0": { + "type": "package", + "compile": { + "ref/net45/_._": {} + }, + "runtime": { + "lib/net45/_._": {} + } + }, + "System.ComponentModel.Annotations/4.0.10": { + "type": "package", + "compile": { + "ref/net46/_._": {} + }, + "runtime": { + "lib/net46/_._": {} + } + }, + "System.Diagnostics.Debug/4.0.10": { + "type": "package", + "compile": { + "ref/net46/_._": {} + }, + "runtime": { + "lib/net46/_._": {} + } + }, + "System.Diagnostics.Tools/4.0.0": { + "type": "package", + "compile": { + "ref/net45/_._": {} + }, + "runtime": { + "lib/net45/_._": {} + } + }, + "System.Diagnostics.Tracing/4.0.20": { + "type": "package", + "compile": { + "ref/net46/_._": {} + }, + "runtime": { + "lib/net46/_._": {} + } + }, + "System.Dynamic.Runtime/4.0.10": { + "type": "package", + "compile": { + "ref/net46/_._": {} + }, + "runtime": { + "lib/net46/_._": {} + } + }, + "System.Globalization/4.0.10": { + "type": "package", + "compile": { + "ref/net46/_._": {} + }, + "runtime": { + "lib/net46/_._": {} + } + }, + "System.Globalization.Calendars/4.0.0": { + "type": "package", + "dependencies": { + "System.Globalization": "4.0.0", + "System.Runtime": "4.0.0" + }, + "frameworkAssemblies": [ + "mscorlib" + ], + "compile": { + "ref/net46/System.Globalization.Calendars.dll": {} + }, + "runtime": { + "lib/net46/System.Globalization.Calendars.dll": {} + } + }, + "System.Globalization.Extensions/4.0.0": { + "type": "package", + "dependencies": { + "System.Globalization": "4.0.10", + "System.Resources.ResourceManager": "4.0.0", + "System.Runtime": "4.0.20", + "System.Runtime.Extensions": "4.0.10", + "System.Runtime.InteropServices": "4.0.20" + }, + "frameworkAssemblies": [ + "mscorlib" + ], + "compile": { + "ref/net46/System.Globalization.Extensions.dll": {} + }, + "runtime": { + "lib/net46/System.Globalization.Extensions.dll": {} + } + }, + "System.IO/4.0.10": { + "type": "package", + "compile": { + "ref/net46/_._": {} + }, + "runtime": { + "lib/net46/_._": {} + } + }, + "System.IO.Compression/4.0.0": { + "type": "package", + "frameworkAssemblies": [ + "System.IO.Compression" + ], + "compile": { + "ref/net45/_._": {} + }, + "runtime": { + "lib/net45/_._": {} + } + }, + "System.IO.Compression.ZipFile/4.0.0": { + "type": "package", + "dependencies": { + "System.IO": "4.0.10", + "System.IO.Compression": "4.0.0", + "System.IO.FileSystem": "4.0.0", + "System.IO.FileSystem.Primitives": "4.0.0", + "System.Resources.ResourceManager": "4.0.0", + "System.Runtime": "4.0.20", + "System.Runtime.Extensions": "4.0.10", + "System.Text.Encoding": "4.0.10" + }, + "frameworkAssemblies": [ + "System.IO.Compression.FileSystem", + "mscorlib" + ], + "compile": { + "ref/net46/System.IO.Compression.ZipFile.dll": {} + }, + "runtime": { + "lib/net46/System.IO.Compression.ZipFile.dll": {} + } + }, + "System.IO.FileSystem/4.0.0": { + "type": "package", + "dependencies": { + "System.IO": "4.0.0", + "System.IO.FileSystem.Primitives": "4.0.0", + "System.Runtime": "4.0.0", + "System.Runtime.Handles": "4.0.0", + "System.Text.Encoding": "4.0.0", + "System.Threading.Tasks": "4.0.0" + }, + "frameworkAssemblies": [ + "mscorlib" + ], + "compile": { + "ref/net46/System.IO.FileSystem.dll": {} + }, + "runtime": { + "lib/net46/System.IO.FileSystem.dll": {} + } + }, + "System.IO.FileSystem.Primitives/4.0.0": { + "type": "package", + "dependencies": { + "System.Runtime": "4.0.20" + }, + "frameworkAssemblies": [ + "mscorlib" + ], + "compile": { + "ref/net46/System.IO.FileSystem.Primitives.dll": {} + }, + "runtime": { + "lib/net46/System.IO.FileSystem.Primitives.dll": {} + } + }, + "System.IO.UnmanagedMemoryStream/4.0.0": { + "type": "package", + "dependencies": { + "System.IO": "4.0.10", + "System.IO.FileSystem.Primitives": "4.0.0", + "System.Resources.ResourceManager": "4.0.0", + "System.Runtime": "4.0.20", + "System.Runtime.InteropServices": "4.0.20", + "System.Threading": "4.0.10", + "System.Threading.Tasks": "4.0.10" + }, + "frameworkAssemblies": [ + "mscorlib" + ], + "compile": { + "ref/net46/System.IO.UnmanagedMemoryStream.dll": {} + }, + "runtime": { + "lib/net46/System.IO.UnmanagedMemoryStream.dll": {} + } + }, + "System.Linq/4.0.0": { + "type": "package", + "compile": { + "ref/net45/_._": {} + }, + "runtime": { + "lib/net45/_._": {} + } + }, + "System.Linq.Expressions/4.0.10": { + "type": "package", + "compile": { + "ref/net46/_._": {} + }, + "runtime": { + "lib/net46/_._": {} + } + }, + "System.Linq.Parallel/4.0.0": { + "type": "package", + "compile": { + "ref/net45/_._": {} + }, + "runtime": { + "lib/net45/_._": {} + } + }, + "System.Linq.Queryable/4.0.0": { + "type": "package", + "compile": { + "ref/net45/_._": {} + }, + "runtime": { + "lib/net45/_._": {} + } + }, + "System.Net.Http/4.0.0": { + "type": "package", + "frameworkAssemblies": [ + "System.Net.Http" + ], + "compile": { + "ref/net45/_._": {} + }, + "runtime": { + "lib/net45/_._": {} + } + }, + "System.Net.NetworkInformation/4.0.0": { + "type": "package", + "compile": { + "ref/net45/_._": {} + }, + "runtime": { + "lib/net45/_._": {} + } + }, + "System.Net.Primitives/4.0.10": { + "type": "package", + "compile": { + "ref/net46/_._": {} + }, + "runtime": { + "lib/net46/_._": {} + } + }, + "System.Numerics.Vectors/4.1.0": { + "type": "package", + "dependencies": { + "System.Globalization": "4.0.10", + "System.Resources.ResourceManager": "4.0.0", + "System.Runtime": "4.0.20", + "System.Runtime.Extensions": "4.0.10" + }, + "frameworkAssemblies": [ + "System.Numerics", + "mscorlib" + ], + "compile": { + "ref/net46/System.Numerics.Vectors.dll": {} + }, + "runtime": { + "lib/net46/System.Numerics.Vectors.dll": {} + } + }, + "System.ObjectModel/4.0.10": { + "type": "package", + "compile": { + "ref/net46/_._": {} + }, + "runtime": { + "lib/net46/_._": {} + } + }, + "System.Reflection/4.0.10": { + "type": "package", + "compile": { + "ref/net46/_._": {} + }, + "runtime": { + "lib/net46/_._": {} + } + }, + "System.Reflection.DispatchProxy/4.0.0": { + "type": "package", + "dependencies": { + "System.Collections": "4.0.10", + "System.Linq": "4.0.0", + "System.Reflection": "4.0.10", + "System.Reflection.Extensions": "4.0.0", + "System.Reflection.Primitives": "4.0.0", + "System.Resources.ResourceManager": "4.0.0", + "System.Runtime": "4.0.20", + "System.Threading": "4.0.10" + }, + "compile": { + "ref/dotnet/System.Reflection.DispatchProxy.dll": {} + }, + "runtime": { + "lib/net46/System.Reflection.DispatchProxy.dll": {} + } + }, + "System.Reflection.Extensions/4.0.0": { + "type": "package", + "compile": { + "ref/net45/_._": {} + }, + "runtime": { + "lib/net45/_._": {} + } + }, + "System.Reflection.Metadata/1.0.22": { + "type": "package", + "dependencies": { + "System.Collections": "4.0.0", + "System.Collections.Immutable": "1.1.37", + "System.Diagnostics.Debug": "4.0.0", + "System.IO": "4.0.0", + "System.Reflection": "4.0.0", + "System.Reflection.Extensions": "4.0.0", + "System.Reflection.Primitives": "4.0.0", + "System.Resources.ResourceManager": "4.0.0", + "System.Runtime": "4.0.0", + "System.Runtime.Extensions": "4.0.0", + "System.Runtime.InteropServices": "4.0.0", + "System.Text.Encoding": "4.0.0", + "System.Text.Encoding.Extensions": "4.0.0", + "System.Threading": "4.0.0" + }, + "compile": { + "lib/dotnet/System.Reflection.Metadata.dll": {} + }, + "runtime": { + "lib/dotnet/System.Reflection.Metadata.dll": {} + } + }, + "System.Reflection.Primitives/4.0.0": { + "type": "package", + "compile": { + "ref/net45/_._": {} + }, + "runtime": { + "lib/net45/_._": {} + } + }, + "System.Reflection.TypeExtensions/4.0.0": { + "type": "package", + "dependencies": { + "System.Reflection": "4.0.0", + "System.Runtime": "4.0.0" + }, + "frameworkAssemblies": [ + "mscorlib" + ], + "compile": { + "ref/net46/System.Reflection.TypeExtensions.dll": {} + }, + "runtime": { + "lib/net46/System.Reflection.TypeExtensions.dll": {} + } + }, + "System.Resources.ResourceManager/4.0.0": { + "type": "package", + "compile": { + "ref/net45/_._": {} + }, + "runtime": { + "lib/net45/_._": {} + } + }, + "System.Runtime/4.0.20": { + "type": "package", + "compile": { + "ref/net46/_._": {} + }, + "runtime": { + "lib/net46/_._": {} + } + }, + "System.Runtime.Extensions/4.0.10": { + "type": "package", + "compile": { + "ref/net46/_._": {} + }, + "runtime": { + "lib/net46/_._": {} + } + }, + "System.Runtime.Handles/4.0.0": { + "type": "package", + "compile": { + "ref/net46/_._": {} + }, + "runtime": { + "lib/net46/_._": {} + } + }, + "System.Runtime.InteropServices/4.0.20": { + "type": "package", + "compile": { + "ref/net46/_._": {} + }, + "runtime": { + "lib/net46/_._": {} + } + }, + "System.Runtime.Numerics/4.0.0": { + "type": "package", + "compile": { + "ref/net45/_._": {} + }, + "runtime": { + "lib/net45/_._": {} + } + }, + "System.Security.Claims/4.0.0": { + "type": "package", + "dependencies": { + "System.Collections": "4.0.0", + "System.Diagnostics.Debug": "4.0.0", + "System.Globalization": "4.0.0", + "System.IO": "4.0.0", + "System.Resources.ResourceManager": "4.0.0", + "System.Runtime": "4.0.20", + "System.Runtime.Extensions": "4.0.0", + "System.Security.Principal": "4.0.0" + }, + "frameworkAssemblies": [ + "mscorlib" + ], + "compile": { + "ref/net46/System.Security.Claims.dll": {} + }, + "runtime": { + "lib/net46/System.Security.Claims.dll": {} + } + }, + "System.Security.Principal/4.0.0": { + "type": "package", + "compile": { + "ref/net45/_._": {} + }, + "runtime": { + "lib/net45/_._": {} + } + }, + "System.Text.Encoding/4.0.10": { + "type": "package", + "compile": { + "ref/net46/_._": {} + }, + "runtime": { + "lib/net46/_._": {} + } + }, + "System.Text.Encoding.Extensions/4.0.10": { + "type": "package", + "compile": { + "ref/net46/_._": {} + }, + "runtime": { + "lib/net46/_._": {} + } + }, + "System.Text.RegularExpressions/4.0.10": { + "type": "package", + "compile": { + "ref/net46/_._": {} + }, + "runtime": { + "lib/net46/_._": {} + } + }, + "System.Threading/4.0.10": { + "type": "package", + "compile": { + "ref/net46/_._": {} + }, + "runtime": { + "lib/net46/_._": {} + } + }, + "System.Threading.Tasks/4.0.10": { + "type": "package", + "compile": { + "ref/net46/_._": {} + }, + "runtime": { + "lib/net46/_._": {} + } + }, + "System.Threading.Tasks.Dataflow/4.5.25": { + "type": "package", + "dependencies": { + "System.Collections": "4.0.0", + "System.Collections.Concurrent": "4.0.0", + "System.Diagnostics.Debug": "4.0.0", + "System.Diagnostics.Tracing": "4.0.0", + "System.Dynamic.Runtime": "4.0.0", + "System.Linq": "4.0.0", + "System.Resources.ResourceManager": "4.0.0", + "System.Runtime": "4.0.0", + "System.Runtime.Extensions": "4.0.0", + "System.Threading": "4.0.0", + "System.Threading.Tasks": "4.0.0" + }, + "compile": { + "lib/dotnet/System.Threading.Tasks.Dataflow.dll": {} + }, + "runtime": { + "lib/dotnet/System.Threading.Tasks.Dataflow.dll": {} + } + }, + "System.Threading.Tasks.Parallel/4.0.0": { + "type": "package", + "compile": { + "ref/net45/_._": {} + }, + "runtime": { + "lib/net45/_._": {} + } + }, + "System.Threading.Timer/4.0.0": { + "type": "package", + "compile": { + "ref/net451/_._": {} + }, + "runtime": { + "lib/net451/_._": {} + } + }, + "System.Xml.ReaderWriter/4.0.10": { + "type": "package", + "compile": { + "ref/net46/_._": {} + }, + "runtime": { + "lib/net46/_._": {} + } + }, + "System.Xml.XDocument/4.0.10": { + "type": "package", + "compile": { + "ref/net46/_._": {} + }, + "runtime": { + "lib/net46/_._": {} + } + } + }, + ".NETFramework,Version=v4.6/win-x64": { + "Microsoft.CSharp/4.0.0": { + "type": "package", + "frameworkAssemblies": [ + "Microsoft.CSharp" + ], + "compile": { + "ref/net45/_._": {} + }, + "runtime": { + "lib/net45/_._": {} + } + }, + "Microsoft.NETCore/5.0.0": { + "type": "package", + "dependencies": { + "Microsoft.CSharp": "4.0.0", + "Microsoft.NETCore.Targets": "1.0.0", + "Microsoft.VisualBasic": "10.0.0", + "System.AppContext": "4.0.0", + "System.Collections": "4.0.10", + "System.Collections.Concurrent": "4.0.10", + "System.Collections.Immutable": "1.1.37", + "System.ComponentModel": "4.0.0", + "System.ComponentModel.Annotations": "4.0.10", + "System.Diagnostics.Debug": "4.0.10", + "System.Diagnostics.Tools": "4.0.0", + "System.Diagnostics.Tracing": "4.0.20", + "System.Dynamic.Runtime": "4.0.10", + "System.Globalization": "4.0.10", + "System.Globalization.Calendars": "4.0.0", + "System.Globalization.Extensions": "4.0.0", + "System.IO": "4.0.10", + "System.IO.Compression": "4.0.0", + "System.IO.Compression.ZipFile": "4.0.0", + "System.IO.FileSystem": "4.0.0", + "System.IO.FileSystem.Primitives": "4.0.0", + "System.IO.UnmanagedMemoryStream": "4.0.0", + "System.Linq": "4.0.0", + "System.Linq.Expressions": "4.0.10", + "System.Linq.Parallel": "4.0.0", + "System.Linq.Queryable": "4.0.0", + "System.Net.Http": "4.0.0", + "System.Net.NetworkInformation": "4.0.0", + "System.Net.Primitives": "4.0.10", + "System.Numerics.Vectors": "4.1.0", + "System.ObjectModel": "4.0.10", + "System.Reflection": "4.0.10", + "System.Reflection.DispatchProxy": "4.0.0", + "System.Reflection.Extensions": "4.0.0", + "System.Reflection.Metadata": "1.0.22", + "System.Reflection.Primitives": "4.0.0", + "System.Reflection.TypeExtensions": "4.0.0", + "System.Resources.ResourceManager": "4.0.0", + "System.Runtime": "4.0.20", + "System.Runtime.Extensions": "4.0.10", + "System.Runtime.Handles": "4.0.0", + "System.Runtime.InteropServices": "4.0.20", + "System.Runtime.Numerics": "4.0.0", + "System.Security.Claims": "4.0.0", + "System.Security.Principal": "4.0.0", + "System.Text.Encoding": "4.0.10", + "System.Text.Encoding.Extensions": "4.0.10", + "System.Text.RegularExpressions": "4.0.10", + "System.Threading": "4.0.10", + "System.Threading.Tasks": "4.0.10", + "System.Threading.Tasks.Dataflow": "4.5.25", + "System.Threading.Tasks.Parallel": "4.0.0", + "System.Threading.Timer": "4.0.0", + "System.Xml.ReaderWriter": "4.0.10", + "System.Xml.XDocument": "4.0.10" + } + }, + "Microsoft.NETCore.Platforms/1.0.0": { + "type": "package" + }, + "Microsoft.NETCore.Portable.Compatibility/1.0.0": { + "type": "package", + "compile": { + "ref/net45/_._": {} + }, + "runtime": { + "lib/net45/_._": {} + } + }, + "Microsoft.NETCore.Targets/1.0.0": { + "type": "package", + "dependencies": { + "Microsoft.NETCore.Platforms": "1.0.0", + "Microsoft.NETCore.Targets.NETFramework": "4.6.0" + } + }, + "Microsoft.NETCore.Targets.NETFramework/4.6.0": { + "type": "package" + }, + "Microsoft.VisualBasic/10.0.0": { + "type": "package", + "frameworkAssemblies": [ + "Microsoft.VisualBasic" + ], + "compile": { + "ref/net45/_._": {} + }, + "runtime": { + "lib/net45/_._": {} + } + }, + "System.AppContext/4.0.0": { + "type": "package", + "dependencies": { + "System.Runtime": "4.0.0" + }, + "frameworkAssemblies": [ + "mscorlib" + ], + "compile": { + "ref/net46/System.AppContext.dll": {} + }, + "runtime": { + "lib/net46/System.AppContext.dll": {} + } + }, + "System.Collections/4.0.10": { + "type": "package", + "compile": { + "ref/net46/_._": {} + }, + "runtime": { + "lib/net46/_._": {} + } + }, + "System.Collections.Concurrent/4.0.10": { + "type": "package", + "compile": { + "ref/net46/_._": {} + }, + "runtime": { + "lib/net46/_._": {} + } + }, + "System.Collections.Immutable/1.1.37": { + "type": "package", + "dependencies": { + "System.Collections": "4.0.0", + "System.Diagnostics.Debug": "4.0.0", + "System.Globalization": "4.0.0", + "System.Linq": "4.0.0", + "System.Resources.ResourceManager": "4.0.0", + "System.Runtime": "4.0.0", + "System.Runtime.Extensions": "4.0.0", + "System.Threading": "4.0.0" + }, + "compile": { + "lib/dotnet/System.Collections.Immutable.dll": {} + }, + "runtime": { + "lib/dotnet/System.Collections.Immutable.dll": {} + } + }, + "System.ComponentModel/4.0.0": { + "type": "package", + "compile": { + "ref/net45/_._": {} + }, + "runtime": { + "lib/net45/_._": {} + } + }, + "System.ComponentModel.Annotations/4.0.10": { + "type": "package", + "compile": { + "ref/net46/_._": {} + }, + "runtime": { + "lib/net46/_._": {} + } + }, + "System.Diagnostics.Debug/4.0.10": { + "type": "package", + "compile": { + "ref/net46/_._": {} + }, + "runtime": { + "lib/net46/_._": {} + } + }, + "System.Diagnostics.Tools/4.0.0": { + "type": "package", + "compile": { + "ref/net45/_._": {} + }, + "runtime": { + "lib/net45/_._": {} + } + }, + "System.Diagnostics.Tracing/4.0.20": { + "type": "package", + "compile": { + "ref/net46/_._": {} + }, + "runtime": { + "lib/net46/_._": {} + } + }, + "System.Dynamic.Runtime/4.0.10": { + "type": "package", + "dependencies": { + "System.Reflection.Emit.ILGeneration": "4.0.0", + "System.Reflection.Emit.Lightweight": "4.0.0" + }, + "compile": { + "ref/net46/_._": {} + }, + "runtime": { + "lib/net46/_._": {} + } + }, + "System.Globalization/4.0.10": { + "type": "package", + "compile": { + "ref/net46/_._": {} + }, + "runtime": { + "lib/net46/_._": {} + } + }, + "System.Globalization.Calendars/4.0.0": { + "type": "package", + "dependencies": { + "System.Globalization": "4.0.0", + "System.Runtime": "4.0.0" + }, + "frameworkAssemblies": [ + "mscorlib" + ], + "compile": { + "ref/net46/System.Globalization.Calendars.dll": {} + }, + "runtime": { + "lib/net46/System.Globalization.Calendars.dll": {} + } + }, + "System.Globalization.Extensions/4.0.0": { + "type": "package", + "dependencies": { + "System.Globalization": "4.0.10", + "System.Resources.ResourceManager": "4.0.0", + "System.Runtime": "4.0.20", + "System.Runtime.Extensions": "4.0.10", + "System.Runtime.InteropServices": "4.0.20" + }, + "frameworkAssemblies": [ + "mscorlib" + ], + "compile": { + "ref/net46/System.Globalization.Extensions.dll": {} + }, + "runtime": { + "lib/net46/System.Globalization.Extensions.dll": {} + } + }, + "System.IO/4.0.10": { + "type": "package", + "compile": { + "ref/net46/_._": {} + }, + "runtime": { + "lib/net46/_._": {} + } + }, + "System.IO.Compression/4.0.0": { + "type": "package", + "frameworkAssemblies": [ + "System.IO.Compression" + ], + "compile": { + "ref/net45/_._": {} + }, + "runtime": { + "lib/net45/_._": {} + } + }, + "System.IO.Compression.ZipFile/4.0.0": { + "type": "package", + "dependencies": { + "System.IO": "4.0.10", + "System.IO.Compression": "4.0.0", + "System.IO.FileSystem": "4.0.0", + "System.IO.FileSystem.Primitives": "4.0.0", + "System.Resources.ResourceManager": "4.0.0", + "System.Runtime": "4.0.20", + "System.Runtime.Extensions": "4.0.10", + "System.Text.Encoding": "4.0.10" + }, + "frameworkAssemblies": [ + "System.IO.Compression.FileSystem", + "mscorlib" + ], + "compile": { + "ref/net46/System.IO.Compression.ZipFile.dll": {} + }, + "runtime": { + "lib/net46/System.IO.Compression.ZipFile.dll": {} + } + }, + "System.IO.FileSystem/4.0.0": { + "type": "package", + "dependencies": { + "System.IO": "4.0.0", + "System.IO.FileSystem.Primitives": "4.0.0", + "System.Runtime": "4.0.0", + "System.Runtime.Handles": "4.0.0", + "System.Text.Encoding": "4.0.0", + "System.Threading.Tasks": "4.0.0" + }, + "frameworkAssemblies": [ + "mscorlib" + ], + "compile": { + "ref/net46/System.IO.FileSystem.dll": {} + }, + "runtime": { + "lib/net46/System.IO.FileSystem.dll": {} + } + }, + "System.IO.FileSystem.Primitives/4.0.0": { + "type": "package", + "dependencies": { + "System.Runtime": "4.0.20" + }, + "frameworkAssemblies": [ + "mscorlib" + ], + "compile": { + "ref/net46/System.IO.FileSystem.Primitives.dll": {} + }, + "runtime": { + "lib/net46/System.IO.FileSystem.Primitives.dll": {} + } + }, + "System.IO.UnmanagedMemoryStream/4.0.0": { + "type": "package", + "dependencies": { + "System.IO": "4.0.10", + "System.IO.FileSystem.Primitives": "4.0.0", + "System.Resources.ResourceManager": "4.0.0", + "System.Runtime": "4.0.20", + "System.Runtime.InteropServices": "4.0.20", + "System.Threading": "4.0.10", + "System.Threading.Tasks": "4.0.10" + }, + "frameworkAssemblies": [ + "mscorlib" + ], + "compile": { + "ref/net46/System.IO.UnmanagedMemoryStream.dll": {} + }, + "runtime": { + "lib/net46/System.IO.UnmanagedMemoryStream.dll": {} + } + }, + "System.Linq/4.0.0": { + "type": "package", + "compile": { + "ref/net45/_._": {} + }, + "runtime": { + "lib/net45/_._": {} + } + }, + "System.Linq.Expressions/4.0.10": { + "type": "package", + "dependencies": { + "System.Reflection.Emit.ILGeneration": "4.0.0", + "System.Reflection.Emit.Lightweight": "4.0.0" + }, + "compile": { + "ref/net46/_._": {} + }, + "runtime": { + "lib/net46/_._": {} + } + }, + "System.Linq.Parallel/4.0.0": { + "type": "package", + "compile": { + "ref/net45/_._": {} + }, + "runtime": { + "lib/net45/_._": {} + } + }, + "System.Linq.Queryable/4.0.0": { + "type": "package", + "compile": { + "ref/net45/_._": {} + }, + "runtime": { + "lib/net45/_._": {} + } + }, + "System.Net.Http/4.0.0": { + "type": "package", + "frameworkAssemblies": [ + "System.Net.Http" + ], + "compile": { + "ref/net45/_._": {} + }, + "runtime": { + "lib/net45/_._": {} + } + }, + "System.Net.NetworkInformation/4.0.10-beta-23123": { + "type": "package", + "compile": { + "ref/net46/_._": {} + }, + "runtime": { + "lib/net46/_._": {} + } + }, + "System.Net.Primitives/4.0.10": { + "type": "package", + "compile": { + "ref/net46/_._": {} + }, + "runtime": { + "lib/net46/_._": {} + } + }, + "System.Numerics.Vectors/4.1.0": { + "type": "package", + "dependencies": { + "System.Globalization": "4.0.10", + "System.Resources.ResourceManager": "4.0.0", + "System.Runtime": "4.0.20", + "System.Runtime.Extensions": "4.0.10" + }, + "frameworkAssemblies": [ + "System.Numerics", + "mscorlib" + ], + "compile": { + "ref/net46/System.Numerics.Vectors.dll": {} + }, + "runtime": { + "lib/net46/System.Numerics.Vectors.dll": {} + } + }, + "System.ObjectModel/4.0.10": { + "type": "package", + "compile": { + "ref/net46/_._": {} + }, + "runtime": { + "lib/net46/_._": {} + } + }, + "System.Reflection/4.0.10": { + "type": "package", + "compile": { + "ref/net46/_._": {} + }, + "runtime": { + "lib/net46/_._": {} + } + }, + "System.Reflection.DispatchProxy/4.0.0": { + "type": "package", + "dependencies": { + "System.Collections": "4.0.10", + "System.Linq": "4.0.0", + "System.Reflection": "4.0.10", + "System.Reflection.Emit": "4.0.0", + "System.Reflection.Emit.ILGeneration": "4.0.0", + "System.Reflection.Extensions": "4.0.0", + "System.Reflection.Primitives": "4.0.0", + "System.Resources.ResourceManager": "4.0.0", + "System.Runtime": "4.0.20", + "System.Threading": "4.0.10" + }, + "compile": { + "ref/dotnet/System.Reflection.DispatchProxy.dll": {} + }, + "runtime": { + "lib/net46/System.Reflection.DispatchProxy.dll": {} + } + }, + "System.Reflection.Emit/4.0.0": { + "type": "package", + "compile": { + "ref/net45/_._": {} + }, + "runtime": { + "lib/net45/_._": {} + } + }, + "System.Reflection.Emit.ILGeneration/4.0.0": { + "type": "package", + "compile": { + "ref/net45/_._": {} + }, + "runtime": { + "lib/net45/_._": {} + } + }, + "System.Reflection.Emit.Lightweight/4.0.0": { + "type": "package", + "compile": { + "ref/net45/_._": {} + }, + "runtime": { + "lib/net45/_._": {} + } + }, + "System.Reflection.Extensions/4.0.0": { + "type": "package", + "compile": { + "ref/net45/_._": {} + }, + "runtime": { + "lib/net45/_._": {} + } + }, + "System.Reflection.Metadata/1.0.22": { + "type": "package", + "dependencies": { + "System.Collections": "4.0.0", + "System.Collections.Immutable": "1.1.37", + "System.Diagnostics.Debug": "4.0.0", + "System.IO": "4.0.0", + "System.Reflection": "4.0.0", + "System.Reflection.Extensions": "4.0.0", + "System.Reflection.Primitives": "4.0.0", + "System.Resources.ResourceManager": "4.0.0", + "System.Runtime": "4.0.0", + "System.Runtime.Extensions": "4.0.0", + "System.Runtime.InteropServices": "4.0.0", + "System.Text.Encoding": "4.0.0", + "System.Text.Encoding.Extensions": "4.0.0", + "System.Threading": "4.0.0" + }, + "compile": { + "lib/dotnet/System.Reflection.Metadata.dll": {} + }, + "runtime": { + "lib/dotnet/System.Reflection.Metadata.dll": {} + } + }, + "System.Reflection.Primitives/4.0.0": { + "type": "package", + "compile": { + "ref/net45/_._": {} + }, + "runtime": { + "lib/net45/_._": {} + } + }, + "System.Reflection.TypeExtensions/4.0.0": { + "type": "package", + "dependencies": { + "System.Reflection": "4.0.0", + "System.Runtime": "4.0.0" + }, + "frameworkAssemblies": [ + "mscorlib" + ], + "compile": { + "ref/net46/System.Reflection.TypeExtensions.dll": {} + }, + "runtime": { + "lib/net46/System.Reflection.TypeExtensions.dll": {} + } + }, + "System.Resources.ResourceManager/4.0.0": { + "type": "package", + "compile": { + "ref/net45/_._": {} + }, + "runtime": { + "lib/net45/_._": {} + } + }, + "System.Runtime/4.0.20": { + "type": "package", + "compile": { + "ref/net46/_._": {} + }, + "runtime": { + "lib/net46/_._": {} + } + }, + "System.Runtime.Extensions/4.0.10": { + "type": "package", + "compile": { + "ref/net46/_._": {} + }, + "runtime": { + "lib/net46/_._": {} + } + }, + "System.Runtime.Handles/4.0.0": { + "type": "package", + "compile": { + "ref/net46/_._": {} + }, + "runtime": { + "lib/net46/_._": {} + } + }, + "System.Runtime.InteropServices/4.0.20": { + "type": "package", + "compile": { + "ref/net46/_._": {} + }, + "runtime": { + "lib/net46/_._": {} + } + }, + "System.Runtime.Numerics/4.0.0": { + "type": "package", + "compile": { + "ref/net45/_._": {} + }, + "runtime": { + "lib/net45/_._": {} + } + }, + "System.Security.Claims/4.0.0": { + "type": "package", + "dependencies": { + "System.Collections": "4.0.0", + "System.Diagnostics.Debug": "4.0.0", + "System.Globalization": "4.0.0", + "System.IO": "4.0.0", + "System.Resources.ResourceManager": "4.0.0", + "System.Runtime": "4.0.20", + "System.Runtime.Extensions": "4.0.0", + "System.Security.Principal": "4.0.0" + }, + "frameworkAssemblies": [ + "mscorlib" + ], + "compile": { + "ref/net46/System.Security.Claims.dll": {} + }, + "runtime": { + "lib/net46/System.Security.Claims.dll": {} + } + }, + "System.Security.Principal/4.0.0": { + "type": "package", + "compile": { + "ref/net45/_._": {} + }, + "runtime": { + "lib/net45/_._": {} + } + }, + "System.Text.Encoding/4.0.10": { + "type": "package", + "compile": { + "ref/net46/_._": {} + }, + "runtime": { + "lib/net46/_._": {} + } + }, + "System.Text.Encoding.Extensions/4.0.10": { + "type": "package", + "compile": { + "ref/net46/_._": {} + }, + "runtime": { + "lib/net46/_._": {} + } + }, + "System.Text.RegularExpressions/4.0.10": { + "type": "package", + "compile": { + "ref/net46/_._": {} + }, + "runtime": { + "lib/net46/_._": {} + } + }, + "System.Threading/4.0.10": { + "type": "package", + "compile": { + "ref/net46/_._": {} + }, + "runtime": { + "lib/net46/_._": {} + } + }, + "System.Threading.Tasks/4.0.10": { + "type": "package", + "compile": { + "ref/net46/_._": {} + }, + "runtime": { + "lib/net46/_._": {} + } + }, + "System.Threading.Tasks.Dataflow/4.5.25": { + "type": "package", + "dependencies": { + "System.Collections": "4.0.0", + "System.Collections.Concurrent": "4.0.0", + "System.Diagnostics.Debug": "4.0.0", + "System.Diagnostics.Tracing": "4.0.0", + "System.Dynamic.Runtime": "4.0.0", + "System.Linq": "4.0.0", + "System.Resources.ResourceManager": "4.0.0", + "System.Runtime": "4.0.0", + "System.Runtime.Extensions": "4.0.0", + "System.Threading": "4.0.0", + "System.Threading.Tasks": "4.0.0" + }, + "compile": { + "lib/dotnet/System.Threading.Tasks.Dataflow.dll": {} + }, + "runtime": { + "lib/dotnet/System.Threading.Tasks.Dataflow.dll": {} + } + }, + "System.Threading.Tasks.Parallel/4.0.0": { + "type": "package", + "compile": { + "ref/net45/_._": {} + }, + "runtime": { + "lib/net45/_._": {} + } + }, + "System.Threading.Timer/4.0.0": { + "type": "package", + "compile": { + "ref/net451/_._": {} + }, + "runtime": { + "lib/net451/_._": {} + } + }, + "System.Xml.ReaderWriter/4.0.10": { + "type": "package", + "compile": { + "ref/net46/_._": {} + }, + "runtime": { + "lib/net46/_._": {} + } + }, + "System.Xml.XDocument/4.0.10": { + "type": "package", + "compile": { + "ref/net46/_._": {} + }, + "runtime": { + "lib/net46/_._": {} + } + } + }, + ".NETFramework,Version=v4.6/win-x86": { + "Microsoft.CSharp/4.0.0": { + "type": "package", + "frameworkAssemblies": [ + "Microsoft.CSharp" + ], + "compile": { + "ref/net45/_._": {} + }, + "runtime": { + "lib/net45/_._": {} + } + }, + "Microsoft.NETCore/5.0.0": { + "type": "package", + "dependencies": { + "Microsoft.CSharp": "4.0.0", + "Microsoft.NETCore.Targets": "1.0.0", + "Microsoft.VisualBasic": "10.0.0", + "System.AppContext": "4.0.0", + "System.Collections": "4.0.10", + "System.Collections.Concurrent": "4.0.10", + "System.Collections.Immutable": "1.1.37", + "System.ComponentModel": "4.0.0", + "System.ComponentModel.Annotations": "4.0.10", + "System.Diagnostics.Debug": "4.0.10", + "System.Diagnostics.Tools": "4.0.0", + "System.Diagnostics.Tracing": "4.0.20", + "System.Dynamic.Runtime": "4.0.10", + "System.Globalization": "4.0.10", + "System.Globalization.Calendars": "4.0.0", + "System.Globalization.Extensions": "4.0.0", + "System.IO": "4.0.10", + "System.IO.Compression": "4.0.0", + "System.IO.Compression.ZipFile": "4.0.0", + "System.IO.FileSystem": "4.0.0", + "System.IO.FileSystem.Primitives": "4.0.0", + "System.IO.UnmanagedMemoryStream": "4.0.0", + "System.Linq": "4.0.0", + "System.Linq.Expressions": "4.0.10", + "System.Linq.Parallel": "4.0.0", + "System.Linq.Queryable": "4.0.0", + "System.Net.Http": "4.0.0", + "System.Net.NetworkInformation": "4.0.0", + "System.Net.Primitives": "4.0.10", + "System.Numerics.Vectors": "4.1.0", + "System.ObjectModel": "4.0.10", + "System.Reflection": "4.0.10", + "System.Reflection.DispatchProxy": "4.0.0", + "System.Reflection.Extensions": "4.0.0", + "System.Reflection.Metadata": "1.0.22", + "System.Reflection.Primitives": "4.0.0", + "System.Reflection.TypeExtensions": "4.0.0", + "System.Resources.ResourceManager": "4.0.0", + "System.Runtime": "4.0.20", + "System.Runtime.Extensions": "4.0.10", + "System.Runtime.Handles": "4.0.0", + "System.Runtime.InteropServices": "4.0.20", + "System.Runtime.Numerics": "4.0.0", + "System.Security.Claims": "4.0.0", + "System.Security.Principal": "4.0.0", + "System.Text.Encoding": "4.0.10", + "System.Text.Encoding.Extensions": "4.0.10", + "System.Text.RegularExpressions": "4.0.10", + "System.Threading": "4.0.10", + "System.Threading.Tasks": "4.0.10", + "System.Threading.Tasks.Dataflow": "4.5.25", + "System.Threading.Tasks.Parallel": "4.0.0", + "System.Threading.Timer": "4.0.0", + "System.Xml.ReaderWriter": "4.0.10", + "System.Xml.XDocument": "4.0.10" + } + }, + "Microsoft.NETCore.Platforms/1.0.0": { + "type": "package" + }, + "Microsoft.NETCore.Portable.Compatibility/1.0.0": { + "type": "package", + "compile": { + "ref/net45/_._": {} + }, + "runtime": { + "lib/net45/_._": {} + } + }, + "Microsoft.NETCore.Targets/1.0.0": { + "type": "package", + "dependencies": { + "Microsoft.NETCore.Platforms": "1.0.0", + "Microsoft.NETCore.Targets.NETFramework": "4.6.0" + } + }, + "Microsoft.NETCore.Targets.NETFramework/4.6.0": { + "type": "package" + }, + "Microsoft.VisualBasic/10.0.0": { + "type": "package", + "frameworkAssemblies": [ + "Microsoft.VisualBasic" + ], + "compile": { + "ref/net45/_._": {} + }, + "runtime": { + "lib/net45/_._": {} + } + }, + "System.AppContext/4.0.0": { + "type": "package", + "dependencies": { + "System.Runtime": "4.0.0" + }, + "frameworkAssemblies": [ + "mscorlib" + ], + "compile": { + "ref/net46/System.AppContext.dll": {} + }, + "runtime": { + "lib/net46/System.AppContext.dll": {} + } + }, + "System.Collections/4.0.10": { + "type": "package", + "compile": { + "ref/net46/_._": {} + }, + "runtime": { + "lib/net46/_._": {} + } + }, + "System.Collections.Concurrent/4.0.10": { + "type": "package", + "compile": { + "ref/net46/_._": {} + }, + "runtime": { + "lib/net46/_._": {} + } + }, + "System.Collections.Immutable/1.1.37": { + "type": "package", + "dependencies": { + "System.Collections": "4.0.0", + "System.Diagnostics.Debug": "4.0.0", + "System.Globalization": "4.0.0", + "System.Linq": "4.0.0", + "System.Resources.ResourceManager": "4.0.0", + "System.Runtime": "4.0.0", + "System.Runtime.Extensions": "4.0.0", + "System.Threading": "4.0.0" + }, + "compile": { + "lib/dotnet/System.Collections.Immutable.dll": {} + }, + "runtime": { + "lib/dotnet/System.Collections.Immutable.dll": {} + } + }, + "System.ComponentModel/4.0.0": { + "type": "package", + "compile": { + "ref/net45/_._": {} + }, + "runtime": { + "lib/net45/_._": {} + } + }, + "System.ComponentModel.Annotations/4.0.10": { + "type": "package", + "compile": { + "ref/net46/_._": {} + }, + "runtime": { + "lib/net46/_._": {} + } + }, + "System.Diagnostics.Debug/4.0.10": { + "type": "package", + "compile": { + "ref/net46/_._": {} + }, + "runtime": { + "lib/net46/_._": {} + } + }, + "System.Diagnostics.Tools/4.0.0": { + "type": "package", + "compile": { + "ref/net45/_._": {} + }, + "runtime": { + "lib/net45/_._": {} + } + }, + "System.Diagnostics.Tracing/4.0.20": { + "type": "package", + "compile": { + "ref/net46/_._": {} + }, + "runtime": { + "lib/net46/_._": {} + } + }, + "System.Dynamic.Runtime/4.0.10": { + "type": "package", + "dependencies": { + "System.Reflection.Emit.ILGeneration": "4.0.0", + "System.Reflection.Emit.Lightweight": "4.0.0" + }, + "compile": { + "ref/net46/_._": {} + }, + "runtime": { + "lib/net46/_._": {} + } + }, + "System.Globalization/4.0.10": { + "type": "package", + "compile": { + "ref/net46/_._": {} + }, + "runtime": { + "lib/net46/_._": {} + } + }, + "System.Globalization.Calendars/4.0.0": { + "type": "package", + "dependencies": { + "System.Globalization": "4.0.0", + "System.Runtime": "4.0.0" + }, + "frameworkAssemblies": [ + "mscorlib" + ], + "compile": { + "ref/net46/System.Globalization.Calendars.dll": {} + }, + "runtime": { + "lib/net46/System.Globalization.Calendars.dll": {} + } + }, + "System.Globalization.Extensions/4.0.0": { + "type": "package", + "dependencies": { + "System.Globalization": "4.0.10", + "System.Resources.ResourceManager": "4.0.0", + "System.Runtime": "4.0.20", + "System.Runtime.Extensions": "4.0.10", + "System.Runtime.InteropServices": "4.0.20" + }, + "frameworkAssemblies": [ + "mscorlib" + ], + "compile": { + "ref/net46/System.Globalization.Extensions.dll": {} + }, + "runtime": { + "lib/net46/System.Globalization.Extensions.dll": {} + } + }, + "System.IO/4.0.10": { + "type": "package", + "compile": { + "ref/net46/_._": {} + }, + "runtime": { + "lib/net46/_._": {} + } + }, + "System.IO.Compression/4.0.0": { + "type": "package", + "frameworkAssemblies": [ + "System.IO.Compression" + ], + "compile": { + "ref/net45/_._": {} + }, + "runtime": { + "lib/net45/_._": {} + } + }, + "System.IO.Compression.ZipFile/4.0.0": { + "type": "package", + "dependencies": { + "System.IO": "4.0.10", + "System.IO.Compression": "4.0.0", + "System.IO.FileSystem": "4.0.0", + "System.IO.FileSystem.Primitives": "4.0.0", + "System.Resources.ResourceManager": "4.0.0", + "System.Runtime": "4.0.20", + "System.Runtime.Extensions": "4.0.10", + "System.Text.Encoding": "4.0.10" + }, + "frameworkAssemblies": [ + "System.IO.Compression.FileSystem", + "mscorlib" + ], + "compile": { + "ref/net46/System.IO.Compression.ZipFile.dll": {} + }, + "runtime": { + "lib/net46/System.IO.Compression.ZipFile.dll": {} + } + }, + "System.IO.FileSystem/4.0.0": { + "type": "package", + "dependencies": { + "System.IO": "4.0.0", + "System.IO.FileSystem.Primitives": "4.0.0", + "System.Runtime": "4.0.0", + "System.Runtime.Handles": "4.0.0", + "System.Text.Encoding": "4.0.0", + "System.Threading.Tasks": "4.0.0" + }, + "frameworkAssemblies": [ + "mscorlib" + ], + "compile": { + "ref/net46/System.IO.FileSystem.dll": {} + }, + "runtime": { + "lib/net46/System.IO.FileSystem.dll": {} + } + }, + "System.IO.FileSystem.Primitives/4.0.0": { + "type": "package", + "dependencies": { + "System.Runtime": "4.0.20" + }, + "frameworkAssemblies": [ + "mscorlib" + ], + "compile": { + "ref/net46/System.IO.FileSystem.Primitives.dll": {} + }, + "runtime": { + "lib/net46/System.IO.FileSystem.Primitives.dll": {} + } + }, + "System.IO.UnmanagedMemoryStream/4.0.0": { + "type": "package", + "dependencies": { + "System.IO": "4.0.10", + "System.IO.FileSystem.Primitives": "4.0.0", + "System.Resources.ResourceManager": "4.0.0", + "System.Runtime": "4.0.20", + "System.Runtime.InteropServices": "4.0.20", + "System.Threading": "4.0.10", + "System.Threading.Tasks": "4.0.10" + }, + "frameworkAssemblies": [ + "mscorlib" + ], + "compile": { + "ref/net46/System.IO.UnmanagedMemoryStream.dll": {} + }, + "runtime": { + "lib/net46/System.IO.UnmanagedMemoryStream.dll": {} + } + }, + "System.Linq/4.0.0": { + "type": "package", + "compile": { + "ref/net45/_._": {} + }, + "runtime": { + "lib/net45/_._": {} + } + }, + "System.Linq.Expressions/4.0.10": { + "type": "package", + "dependencies": { + "System.Reflection.Emit.ILGeneration": "4.0.0", + "System.Reflection.Emit.Lightweight": "4.0.0" + }, + "compile": { + "ref/net46/_._": {} + }, + "runtime": { + "lib/net46/_._": {} + } + }, + "System.Linq.Parallel/4.0.0": { + "type": "package", + "compile": { + "ref/net45/_._": {} + }, + "runtime": { + "lib/net45/_._": {} + } + }, + "System.Linq.Queryable/4.0.0": { + "type": "package", + "compile": { + "ref/net45/_._": {} + }, + "runtime": { + "lib/net45/_._": {} + } + }, + "System.Net.Http/4.0.0": { + "type": "package", + "frameworkAssemblies": [ + "System.Net.Http" + ], + "compile": { + "ref/net45/_._": {} + }, + "runtime": { + "lib/net45/_._": {} + } + }, + "System.Net.NetworkInformation/4.0.10-beta-23123": { + "type": "package", + "compile": { + "ref/net46/_._": {} + }, + "runtime": { + "lib/net46/_._": {} + } + }, + "System.Net.Primitives/4.0.10": { + "type": "package", + "compile": { + "ref/net46/_._": {} + }, + "runtime": { + "lib/net46/_._": {} + } + }, + "System.Numerics.Vectors/4.1.0": { + "type": "package", + "dependencies": { + "System.Globalization": "4.0.10", + "System.Resources.ResourceManager": "4.0.0", + "System.Runtime": "4.0.20", + "System.Runtime.Extensions": "4.0.10" + }, + "frameworkAssemblies": [ + "System.Numerics", + "mscorlib" + ], + "compile": { + "ref/net46/System.Numerics.Vectors.dll": {} + }, + "runtime": { + "lib/net46/System.Numerics.Vectors.dll": {} + } + }, + "System.ObjectModel/4.0.10": { + "type": "package", + "compile": { + "ref/net46/_._": {} + }, + "runtime": { + "lib/net46/_._": {} + } + }, + "System.Reflection/4.0.10": { + "type": "package", + "compile": { + "ref/net46/_._": {} + }, + "runtime": { + "lib/net46/_._": {} + } + }, + "System.Reflection.DispatchProxy/4.0.0": { + "type": "package", + "dependencies": { + "System.Collections": "4.0.10", + "System.Linq": "4.0.0", + "System.Reflection": "4.0.10", + "System.Reflection.Emit": "4.0.0", + "System.Reflection.Emit.ILGeneration": "4.0.0", + "System.Reflection.Extensions": "4.0.0", + "System.Reflection.Primitives": "4.0.0", + "System.Resources.ResourceManager": "4.0.0", + "System.Runtime": "4.0.20", + "System.Threading": "4.0.10" + }, + "compile": { + "ref/dotnet/System.Reflection.DispatchProxy.dll": {} + }, + "runtime": { + "lib/net46/System.Reflection.DispatchProxy.dll": {} + } + }, + "System.Reflection.Emit/4.0.0": { + "type": "package", + "compile": { + "ref/net45/_._": {} + }, + "runtime": { + "lib/net45/_._": {} + } + }, + "System.Reflection.Emit.ILGeneration/4.0.0": { + "type": "package", + "compile": { + "ref/net45/_._": {} + }, + "runtime": { + "lib/net45/_._": {} + } + }, + "System.Reflection.Emit.Lightweight/4.0.0": { + "type": "package", + "compile": { + "ref/net45/_._": {} + }, + "runtime": { + "lib/net45/_._": {} + } + }, + "System.Reflection.Extensions/4.0.0": { + "type": "package", + "compile": { + "ref/net45/_._": {} + }, + "runtime": { + "lib/net45/_._": {} + } + }, + "System.Reflection.Metadata/1.0.22": { + "type": "package", + "dependencies": { + "System.Collections": "4.0.0", + "System.Collections.Immutable": "1.1.37", + "System.Diagnostics.Debug": "4.0.0", + "System.IO": "4.0.0", + "System.Reflection": "4.0.0", + "System.Reflection.Extensions": "4.0.0", + "System.Reflection.Primitives": "4.0.0", + "System.Resources.ResourceManager": "4.0.0", + "System.Runtime": "4.0.0", + "System.Runtime.Extensions": "4.0.0", + "System.Runtime.InteropServices": "4.0.0", + "System.Text.Encoding": "4.0.0", + "System.Text.Encoding.Extensions": "4.0.0", + "System.Threading": "4.0.0" + }, + "compile": { + "lib/dotnet/System.Reflection.Metadata.dll": {} + }, + "runtime": { + "lib/dotnet/System.Reflection.Metadata.dll": {} + } + }, + "System.Reflection.Primitives/4.0.0": { + "type": "package", + "compile": { + "ref/net45/_._": {} + }, + "runtime": { + "lib/net45/_._": {} + } + }, + "System.Reflection.TypeExtensions/4.0.0": { + "type": "package", + "dependencies": { + "System.Reflection": "4.0.0", + "System.Runtime": "4.0.0" + }, + "frameworkAssemblies": [ + "mscorlib" + ], + "compile": { + "ref/net46/System.Reflection.TypeExtensions.dll": {} + }, + "runtime": { + "lib/net46/System.Reflection.TypeExtensions.dll": {} + } + }, + "System.Resources.ResourceManager/4.0.0": { + "type": "package", + "compile": { + "ref/net45/_._": {} + }, + "runtime": { + "lib/net45/_._": {} + } + }, + "System.Runtime/4.0.20": { + "type": "package", + "compile": { + "ref/net46/_._": {} + }, + "runtime": { + "lib/net46/_._": {} + } + }, + "System.Runtime.Extensions/4.0.10": { + "type": "package", + "compile": { + "ref/net46/_._": {} + }, + "runtime": { + "lib/net46/_._": {} + } + }, + "System.Runtime.Handles/4.0.0": { + "type": "package", + "compile": { + "ref/net46/_._": {} + }, + "runtime": { + "lib/net46/_._": {} + } + }, + "System.Runtime.InteropServices/4.0.20": { + "type": "package", + "compile": { + "ref/net46/_._": {} + }, + "runtime": { + "lib/net46/_._": {} + } + }, + "System.Runtime.Numerics/4.0.0": { + "type": "package", + "compile": { + "ref/net45/_._": {} + }, + "runtime": { + "lib/net45/_._": {} + } + }, + "System.Security.Claims/4.0.0": { + "type": "package", + "dependencies": { + "System.Collections": "4.0.0", + "System.Diagnostics.Debug": "4.0.0", + "System.Globalization": "4.0.0", + "System.IO": "4.0.0", + "System.Resources.ResourceManager": "4.0.0", + "System.Runtime": "4.0.20", + "System.Runtime.Extensions": "4.0.0", + "System.Security.Principal": "4.0.0" + }, + "frameworkAssemblies": [ + "mscorlib" + ], + "compile": { + "ref/net46/System.Security.Claims.dll": {} + }, + "runtime": { + "lib/net46/System.Security.Claims.dll": {} + } + }, + "System.Security.Principal/4.0.0": { + "type": "package", + "compile": { + "ref/net45/_._": {} + }, + "runtime": { + "lib/net45/_._": {} + } + }, + "System.Text.Encoding/4.0.10": { + "type": "package", + "compile": { + "ref/net46/_._": {} + }, + "runtime": { + "lib/net46/_._": {} + } + }, + "System.Text.Encoding.Extensions/4.0.10": { + "type": "package", + "compile": { + "ref/net46/_._": {} + }, + "runtime": { + "lib/net46/_._": {} + } + }, + "System.Text.RegularExpressions/4.0.10": { + "type": "package", + "compile": { + "ref/net46/_._": {} + }, + "runtime": { + "lib/net46/_._": {} + } + }, + "System.Threading/4.0.10": { + "type": "package", + "compile": { + "ref/net46/_._": {} + }, + "runtime": { + "lib/net46/_._": {} + } + }, + "System.Threading.Tasks/4.0.10": { + "type": "package", + "compile": { + "ref/net46/_._": {} + }, + "runtime": { + "lib/net46/_._": {} + } + }, + "System.Threading.Tasks.Dataflow/4.5.25": { + "type": "package", + "dependencies": { + "System.Collections": "4.0.0", + "System.Collections.Concurrent": "4.0.0", + "System.Diagnostics.Debug": "4.0.0", + "System.Diagnostics.Tracing": "4.0.0", + "System.Dynamic.Runtime": "4.0.0", + "System.Linq": "4.0.0", + "System.Resources.ResourceManager": "4.0.0", + "System.Runtime": "4.0.0", + "System.Runtime.Extensions": "4.0.0", + "System.Threading": "4.0.0", + "System.Threading.Tasks": "4.0.0" + }, + "compile": { + "lib/dotnet/System.Threading.Tasks.Dataflow.dll": {} + }, + "runtime": { + "lib/dotnet/System.Threading.Tasks.Dataflow.dll": {} + } + }, + "System.Threading.Tasks.Parallel/4.0.0": { + "type": "package", + "compile": { + "ref/net45/_._": {} + }, + "runtime": { + "lib/net45/_._": {} + } + }, + "System.Threading.Timer/4.0.0": { + "type": "package", + "compile": { + "ref/net451/_._": {} + }, + "runtime": { + "lib/net451/_._": {} + } + }, + "System.Xml.ReaderWriter/4.0.10": { + "type": "package", + "compile": { + "ref/net46/_._": {} + }, + "runtime": { + "lib/net46/_._": {} + } + }, + "System.Xml.XDocument/4.0.10": { + "type": "package", + "compile": { + "ref/net46/_._": {} + }, + "runtime": { + "lib/net46/_._": {} + } + } + }, + ".NETPlatform,Version=v5.0": { + "Microsoft.CSharp/4.0.0": { + "type": "package", + "dependencies": { + "System.Collections": "4.0.10", + "System.Diagnostics.Debug": "4.0.10", + "System.Dynamic.Runtime": "4.0.0", + "System.Globalization": "4.0.10", + "System.Linq": "4.0.0", + "System.Linq.Expressions": "4.0.0", + "System.ObjectModel": "4.0.10", + "System.Reflection": "4.0.10", + "System.Reflection.Extensions": "4.0.0", + "System.Reflection.Primitives": "4.0.0", + "System.Reflection.TypeExtensions": "4.0.0", + "System.Resources.ResourceManager": "4.0.0", + "System.Runtime": "4.0.20", + "System.Runtime.Extensions": "4.0.10", + "System.Runtime.InteropServices": "4.0.20", + "System.Threading": "4.0.10" + }, + "compile": { + "ref/dotnet/Microsoft.CSharp.dll": {} + }, + "runtime": { + "lib/dotnet/Microsoft.CSharp.dll": {} + } + }, + "Microsoft.NETCore/5.0.0": { + "type": "package", + "dependencies": { + "Microsoft.CSharp": "4.0.0", + "Microsoft.NETCore.Targets": "1.0.0", + "Microsoft.VisualBasic": "10.0.0", + "System.AppContext": "4.0.0", + "System.Collections": "4.0.10", + "System.Collections.Concurrent": "4.0.10", + "System.Collections.Immutable": "1.1.37", + "System.ComponentModel": "4.0.0", + "System.ComponentModel.Annotations": "4.0.10", + "System.Diagnostics.Debug": "4.0.10", + "System.Diagnostics.Tools": "4.0.0", + "System.Diagnostics.Tracing": "4.0.20", + "System.Dynamic.Runtime": "4.0.10", + "System.Globalization": "4.0.10", + "System.Globalization.Calendars": "4.0.0", + "System.Globalization.Extensions": "4.0.0", + "System.IO": "4.0.10", + "System.IO.Compression": "4.0.0", + "System.IO.Compression.ZipFile": "4.0.0", + "System.IO.FileSystem": "4.0.0", + "System.IO.FileSystem.Primitives": "4.0.0", + "System.IO.UnmanagedMemoryStream": "4.0.0", + "System.Linq": "4.0.0", + "System.Linq.Expressions": "4.0.10", + "System.Linq.Parallel": "4.0.0", + "System.Linq.Queryable": "4.0.0", + "System.Net.Http": "4.0.0", + "System.Net.NetworkInformation": "4.0.0", + "System.Net.Primitives": "4.0.10", + "System.Numerics.Vectors": "4.1.0", + "System.ObjectModel": "4.0.10", + "System.Reflection": "4.0.10", + "System.Reflection.DispatchProxy": "4.0.0", + "System.Reflection.Extensions": "4.0.0", + "System.Reflection.Metadata": "1.0.22", + "System.Reflection.Primitives": "4.0.0", + "System.Reflection.TypeExtensions": "4.0.0", + "System.Resources.ResourceManager": "4.0.0", + "System.Runtime": "4.0.20", + "System.Runtime.Extensions": "4.0.10", + "System.Runtime.Handles": "4.0.0", + "System.Runtime.InteropServices": "4.0.20", + "System.Runtime.Numerics": "4.0.0", + "System.Security.Claims": "4.0.0", + "System.Security.Principal": "4.0.0", + "System.Text.Encoding": "4.0.10", + "System.Text.Encoding.Extensions": "4.0.10", + "System.Text.RegularExpressions": "4.0.10", + "System.Threading": "4.0.10", + "System.Threading.Tasks": "4.0.10", + "System.Threading.Tasks.Dataflow": "4.5.25", + "System.Threading.Tasks.Parallel": "4.0.0", + "System.Threading.Timer": "4.0.0", + "System.Xml.ReaderWriter": "4.0.10", + "System.Xml.XDocument": "4.0.10" + } + }, + "Microsoft.NETCore.Platforms/1.0.0": { + "type": "package" + }, + "Microsoft.NETCore.Portable.Compatibility/1.0.0": { + "type": "package", + "compile": { + "ref/dotnet/System.ComponentModel.DataAnnotations.dll": {}, + "ref/dotnet/System.Core.dll": {}, + "ref/dotnet/System.Net.dll": {}, + "ref/dotnet/System.Numerics.dll": {}, + "ref/dotnet/System.Runtime.Serialization.dll": {}, + "ref/dotnet/System.ServiceModel.Web.dll": {}, + "ref/dotnet/System.ServiceModel.dll": {}, + "ref/dotnet/System.Windows.dll": {}, + "ref/dotnet/System.Xml.Linq.dll": {}, + "ref/dotnet/System.Xml.Serialization.dll": {}, + "ref/dotnet/System.Xml.dll": {}, + "ref/dotnet/System.dll": {}, + "ref/dotnet/mscorlib.dll": {} + } + }, + "Microsoft.NETCore.Targets/1.0.0": { + "type": "package", + "dependencies": { + "Microsoft.NETCore.Platforms": "1.0.0" + } + }, + "Microsoft.VisualBasic/10.0.0": { + "type": "package", + "dependencies": { + "System.Collections": "4.0.10", + "System.Diagnostics.Debug": "4.0.10", + "System.Dynamic.Runtime": "4.0.10", + "System.Globalization": "4.0.10", + "System.Linq": "4.0.0", + "System.Linq.Expressions": "4.0.10", + "System.ObjectModel": "4.0.10", + "System.Reflection": "4.0.10", + "System.Reflection.Extensions": "4.0.0", + "System.Reflection.Primitives": "4.0.0", + "System.Reflection.TypeExtensions": "4.0.0", + "System.Resources.ResourceManager": "4.0.0", + "System.Runtime": "4.0.20", + "System.Runtime.Extensions": "4.0.10", + "System.Runtime.InteropServices": "4.0.20", + "System.Threading": "4.0.10" + }, + "compile": { + "ref/dotnet/Microsoft.VisualBasic.dll": {} + }, + "runtime": { + "lib/dotnet/Microsoft.VisualBasic.dll": {} + } + }, + "System.AppContext/4.0.0": { + "type": "package", + "dependencies": { + "System.Runtime": "4.0.0" + }, + "compile": { + "ref/dotnet/System.AppContext.dll": {} + } + }, + "System.Collections/4.0.10": { + "type": "package", + "dependencies": { + "System.Runtime": "4.0.0" + }, + "compile": { + "ref/dotnet/System.Collections.dll": {} + } + }, + "System.Collections.Concurrent/4.0.10": { + "type": "package", + "dependencies": { + "System.Collections": "4.0.10", + "System.Diagnostics.Debug": "4.0.10", + "System.Diagnostics.Tracing": "4.0.20", + "System.Globalization": "4.0.10", + "System.Resources.ResourceManager": "4.0.0", + "System.Runtime": "4.0.20", + "System.Runtime.Extensions": "4.0.10", + "System.Threading": "4.0.10", + "System.Threading.Tasks": "4.0.10" + }, + "compile": { + "ref/dotnet/System.Collections.Concurrent.dll": {} + }, + "runtime": { + "lib/dotnet/System.Collections.Concurrent.dll": {} + } + }, + "System.Collections.Immutable/1.1.37": { + "type": "package", + "dependencies": { + "System.Collections": "4.0.0", + "System.Diagnostics.Debug": "4.0.0", + "System.Globalization": "4.0.0", + "System.Linq": "4.0.0", + "System.Resources.ResourceManager": "4.0.0", + "System.Runtime": "4.0.0", + "System.Runtime.Extensions": "4.0.0", + "System.Threading": "4.0.0" + }, + "compile": { + "lib/dotnet/System.Collections.Immutable.dll": {} + }, + "runtime": { + "lib/dotnet/System.Collections.Immutable.dll": {} + } + }, + "System.ComponentModel/4.0.0": { + "type": "package", + "dependencies": { + "System.Runtime": "4.0.20" + }, + "compile": { + "ref/dotnet/System.ComponentModel.dll": {} + }, + "runtime": { + "lib/dotnet/System.ComponentModel.dll": {} + } + }, + "System.ComponentModel.Annotations/4.0.10": { + "type": "package", + "dependencies": { + "System.Collections": "4.0.10", + "System.ComponentModel": "4.0.0", + "System.Globalization": "4.0.10", + "System.Linq": "4.0.0", + "System.Reflection": "4.0.10", + "System.Reflection.Extensions": "4.0.0", + "System.Resources.ResourceManager": "4.0.0", + "System.Runtime": "4.0.20", + "System.Runtime.Extensions": "4.0.10", + "System.Text.RegularExpressions": "4.0.10", + "System.Threading": "4.0.10" + }, + "compile": { + "ref/dotnet/System.ComponentModel.Annotations.dll": {} + }, + "runtime": { + "lib/dotnet/System.ComponentModel.Annotations.dll": {} + } + }, + "System.Diagnostics.Debug/4.0.10": { + "type": "package", + "dependencies": { + "System.Runtime": "4.0.0" + }, + "compile": { + "ref/dotnet/System.Diagnostics.Debug.dll": {} + } + }, + "System.Diagnostics.Tools/4.0.0": { + "type": "package", + "dependencies": { + "System.Runtime": "4.0.0" + }, + "compile": { + "ref/dotnet/System.Diagnostics.Tools.dll": {} + } + }, + "System.Diagnostics.Tracing/4.0.20": { + "type": "package", + "dependencies": { + "System.Runtime": "4.0.0" + }, + "compile": { + "ref/dotnet/System.Diagnostics.Tracing.dll": {} + } + }, + "System.Dynamic.Runtime/4.0.10": { + "type": "package", + "dependencies": { + "System.Linq.Expressions": "4.0.10", + "System.ObjectModel": "4.0.0", + "System.Reflection": "4.0.0", + "System.Runtime": "4.0.20" + }, + "compile": { + "ref/dotnet/System.Dynamic.Runtime.dll": {} + } + }, + "System.Globalization/4.0.10": { + "type": "package", + "dependencies": { + "System.Runtime": "4.0.0" + }, + "compile": { + "ref/dotnet/System.Globalization.dll": {} + } + }, + "System.Globalization.Calendars/4.0.0": { + "type": "package", + "dependencies": { + "System.Globalization": "4.0.0", + "System.Runtime": "4.0.0" + }, + "compile": { + "ref/dotnet/System.Globalization.Calendars.dll": {} + } + }, + "System.Globalization.Extensions/4.0.0": { + "type": "package", + "dependencies": { + "System.Globalization": "4.0.10", + "System.Resources.ResourceManager": "4.0.0", + "System.Runtime": "4.0.20", + "System.Runtime.Extensions": "4.0.10", + "System.Runtime.InteropServices": "4.0.20" + }, + "compile": { + "ref/dotnet/System.Globalization.Extensions.dll": {} + }, + "runtime": { + "lib/dotnet/System.Globalization.Extensions.dll": {} + } + }, + "System.IO/4.0.10": { + "type": "package", + "dependencies": { + "System.Runtime": "4.0.20", + "System.Text.Encoding": "4.0.0", + "System.Threading.Tasks": "4.0.0" + }, + "compile": { + "ref/dotnet/System.IO.dll": {} + } + }, + "System.IO.Compression/4.0.0": { + "type": "package", + "dependencies": { + "System.Collections": "4.0.0", + "System.IO": "4.0.0", + "System.Resources.ResourceManager": "4.0.0", + "System.Runtime": "4.0.0", + "System.Runtime.Extensions": "4.0.0", + "System.Runtime.InteropServices": "4.0.0", + "System.Text.Encoding": "4.0.0", + "System.Threading": "4.0.0", + "System.Threading.Tasks": "4.0.0" + }, + "compile": { + "ref/dotnet/System.IO.Compression.dll": {} + }, + "runtime": { + "lib/dotnet/System.IO.Compression.dll": {} + } + }, + "System.IO.Compression.ZipFile/4.0.0": { + "type": "package", + "dependencies": { + "System.IO": "4.0.10", + "System.IO.Compression": "4.0.0", + "System.IO.FileSystem": "4.0.0", + "System.IO.FileSystem.Primitives": "4.0.0", + "System.Resources.ResourceManager": "4.0.0", + "System.Runtime": "4.0.20", + "System.Runtime.Extensions": "4.0.10", + "System.Text.Encoding": "4.0.10" + }, + "compile": { + "ref/dotnet/System.IO.Compression.ZipFile.dll": {} + }, + "runtime": { + "lib/dotnet/System.IO.Compression.ZipFile.dll": {} + } + }, + "System.IO.FileSystem/4.0.0": { + "type": "package", + "dependencies": { + "System.IO": "4.0.0", + "System.IO.FileSystem.Primitives": "4.0.0", + "System.Runtime": "4.0.0", + "System.Runtime.Handles": "4.0.0", + "System.Text.Encoding": "4.0.0", + "System.Threading.Tasks": "4.0.0" + }, + "compile": { + "ref/dotnet/System.IO.FileSystem.dll": {} + } + }, + "System.IO.FileSystem.Primitives/4.0.0": { + "type": "package", + "dependencies": { + "System.Runtime": "4.0.20" + }, + "compile": { + "ref/dotnet/System.IO.FileSystem.Primitives.dll": {} + }, + "runtime": { + "lib/dotnet/System.IO.FileSystem.Primitives.dll": {} + } + }, + "System.IO.UnmanagedMemoryStream/4.0.0": { + "type": "package", + "dependencies": { + "System.IO": "4.0.10", + "System.IO.FileSystem.Primitives": "4.0.0", + "System.Resources.ResourceManager": "4.0.0", + "System.Runtime": "4.0.20", + "System.Runtime.InteropServices": "4.0.20", + "System.Threading": "4.0.10", + "System.Threading.Tasks": "4.0.10" + }, + "compile": { + "ref/dotnet/System.IO.UnmanagedMemoryStream.dll": {} + }, + "runtime": { + "lib/dotnet/System.IO.UnmanagedMemoryStream.dll": {} + } + }, + "System.Linq/4.0.0": { + "type": "package", + "dependencies": { + "System.Collections": "4.0.10", + "System.Diagnostics.Debug": "4.0.10", + "System.Resources.ResourceManager": "4.0.0", + "System.Runtime": "4.0.20", + "System.Runtime.Extensions": "4.0.10" + }, + "compile": { + "ref/dotnet/System.Linq.dll": {} + }, + "runtime": { + "lib/dotnet/System.Linq.dll": {} + } + }, + "System.Linq.Expressions/4.0.10": { + "type": "package", + "dependencies": { + "System.Reflection": "4.0.0", + "System.Runtime": "4.0.0" + }, + "compile": { + "ref/dotnet/System.Linq.Expressions.dll": {} + } + }, + "System.Linq.Parallel/4.0.0": { + "type": "package", + "dependencies": { + "System.Collections": "4.0.10", + "System.Collections.Concurrent": "4.0.10", + "System.Diagnostics.Debug": "4.0.10", + "System.Diagnostics.Tracing": "4.0.20", + "System.Linq": "4.0.0", + "System.Resources.ResourceManager": "4.0.0", + "System.Runtime": "4.0.20", + "System.Runtime.Extensions": "4.0.10", + "System.Threading": "4.0.10", + "System.Threading.Tasks": "4.0.10" + }, + "compile": { + "ref/dotnet/System.Linq.Parallel.dll": {} + }, + "runtime": { + "lib/dotnet/System.Linq.Parallel.dll": {} + } + }, + "System.Linq.Queryable/4.0.0": { + "type": "package", + "dependencies": { + "System.Collections": "4.0.10", + "System.Linq": "4.0.0", + "System.Linq.Expressions": "4.0.10", + "System.Reflection": "4.0.10", + "System.Reflection.Extensions": "4.0.0", + "System.Resources.ResourceManager": "4.0.0", + "System.Runtime": "4.0.20" + }, + "compile": { + "ref/dotnet/System.Linq.Queryable.dll": {} + }, + "runtime": { + "lib/dotnet/System.Linq.Queryable.dll": {} + } + }, + "System.Net.Http/4.0.0": { + "type": "package", + "dependencies": { + "System.IO": "4.0.0", + "System.Net.Primitives": "4.0.0", + "System.Runtime": "4.0.0", + "System.Text.Encoding": "4.0.0", + "System.Threading.Tasks": "4.0.0" + }, + "compile": { + "ref/dotnet/System.Net.Http.dll": {} + } + }, + "System.Net.NetworkInformation/4.0.0": { + "type": "package", + "dependencies": { + "System.Runtime": "4.0.0" + }, + "compile": { + "ref/dotnet/System.Net.NetworkInformation.dll": {} + } + }, + "System.Net.Primitives/4.0.10": { + "type": "package", + "dependencies": { + "System.Runtime": "4.0.0", + "System.Runtime.Handles": "4.0.0" + }, + "compile": { + "ref/dotnet/System.Net.Primitives.dll": {} + } + }, + "System.Numerics.Vectors/4.1.0": { + "type": "package", + "dependencies": { + "System.Globalization": "4.0.10", + "System.Resources.ResourceManager": "4.0.0", + "System.Runtime": "4.0.20", + "System.Runtime.Extensions": "4.0.10" + }, + "compile": { + "ref/dotnet/System.Numerics.Vectors.dll": {} + }, + "runtime": { + "lib/dotnet/System.Numerics.Vectors.dll": {} + } + }, + "System.ObjectModel/4.0.10": { + "type": "package", + "dependencies": { + "System.Collections": "4.0.10", + "System.Diagnostics.Debug": "4.0.10", + "System.Resources.ResourceManager": "4.0.0", + "System.Runtime": "4.0.20", + "System.Threading": "4.0.10" + }, + "compile": { + "ref/dotnet/System.ObjectModel.dll": {} + }, + "runtime": { + "lib/dotnet/System.ObjectModel.dll": {} + } + }, + "System.Reflection/4.0.10": { + "type": "package", + "dependencies": { + "System.IO": "4.0.0", + "System.Reflection.Primitives": "4.0.0", + "System.Runtime": "4.0.20" + }, + "compile": { + "ref/dotnet/System.Reflection.dll": {} + } + }, + "System.Reflection.DispatchProxy/4.0.0": { + "type": "package", + "dependencies": { + "System.Reflection": "4.0.0", + "System.Runtime": "4.0.0" + }, + "compile": { + "ref/dotnet/System.Reflection.DispatchProxy.dll": {} + } + }, + "System.Reflection.Extensions/4.0.0": { + "type": "package", + "dependencies": { + "System.Reflection": "4.0.0", + "System.Runtime": "4.0.0" + }, + "compile": { + "ref/dotnet/System.Reflection.Extensions.dll": {} + } + }, + "System.Reflection.Metadata/1.0.22": { + "type": "package", + "dependencies": { + "System.Collections": "4.0.0", + "System.Collections.Immutable": "1.1.37", + "System.Diagnostics.Debug": "4.0.0", + "System.IO": "4.0.0", + "System.Reflection": "4.0.0", + "System.Reflection.Extensions": "4.0.0", + "System.Reflection.Primitives": "4.0.0", + "System.Resources.ResourceManager": "4.0.0", + "System.Runtime": "4.0.0", + "System.Runtime.Extensions": "4.0.0", + "System.Runtime.InteropServices": "4.0.0", + "System.Text.Encoding": "4.0.0", + "System.Text.Encoding.Extensions": "4.0.0", + "System.Threading": "4.0.0" + }, + "compile": { + "lib/dotnet/System.Reflection.Metadata.dll": {} + }, + "runtime": { + "lib/dotnet/System.Reflection.Metadata.dll": {} + } + }, + "System.Reflection.Primitives/4.0.0": { + "type": "package", + "dependencies": { + "System.Runtime": "4.0.0" + }, + "compile": { + "ref/dotnet/System.Reflection.Primitives.dll": {} + } + }, + "System.Reflection.TypeExtensions/4.0.0": { + "type": "package", + "dependencies": { + "System.Reflection": "4.0.0", + "System.Runtime": "4.0.0" + }, + "compile": { + "ref/dotnet/System.Reflection.TypeExtensions.dll": {} + } + }, + "System.Resources.ResourceManager/4.0.0": { + "type": "package", + "dependencies": { + "System.Globalization": "4.0.0", + "System.Reflection": "4.0.0", + "System.Runtime": "4.0.0" + }, + "compile": { + "ref/dotnet/System.Resources.ResourceManager.dll": {} + } + }, + "System.Runtime/4.0.20": { + "type": "package", + "compile": { + "ref/dotnet/System.Runtime.dll": {} + } + }, + "System.Runtime.Extensions/4.0.10": { + "type": "package", + "dependencies": { + "System.Runtime": "4.0.20" + }, + "compile": { + "ref/dotnet/System.Runtime.Extensions.dll": {} + } + }, + "System.Runtime.Handles/4.0.0": { + "type": "package", + "dependencies": { + "System.Runtime": "4.0.0" + }, + "compile": { + "ref/dotnet/System.Runtime.Handles.dll": {} + } + }, + "System.Runtime.InteropServices/4.0.20": { + "type": "package", + "dependencies": { + "System.Reflection": "4.0.0", + "System.Reflection.Primitives": "4.0.0", + "System.Runtime": "4.0.0", + "System.Runtime.Handles": "4.0.0" + }, + "compile": { + "ref/dotnet/System.Runtime.InteropServices.dll": {} + } + }, + "System.Runtime.Numerics/4.0.0": { + "type": "package", + "dependencies": { + "System.Globalization": "4.0.10", + "System.Resources.ResourceManager": "4.0.0", + "System.Runtime": "4.0.20", + "System.Runtime.Extensions": "4.0.10" + }, + "compile": { + "ref/dotnet/System.Runtime.Numerics.dll": {} + }, + "runtime": { + "lib/dotnet/System.Runtime.Numerics.dll": {} + } + }, + "System.Security.Claims/4.0.0": { + "type": "package", + "dependencies": { + "System.Collections": "4.0.0", + "System.Diagnostics.Debug": "4.0.0", + "System.Globalization": "4.0.0", + "System.IO": "4.0.0", + "System.Resources.ResourceManager": "4.0.0", + "System.Runtime": "4.0.20", + "System.Runtime.Extensions": "4.0.0", + "System.Security.Principal": "4.0.0" + }, + "compile": { + "ref/dotnet/System.Security.Claims.dll": {} + }, + "runtime": { + "lib/dotnet/System.Security.Claims.dll": {} + } + }, + "System.Security.Principal/4.0.0": { + "type": "package", + "dependencies": { + "System.Runtime": "4.0.0" + }, + "compile": { + "ref/dotnet/System.Security.Principal.dll": {} + }, + "runtime": { + "lib/dotnet/System.Security.Principal.dll": {} + } + }, + "System.Text.Encoding/4.0.10": { + "type": "package", + "dependencies": { + "System.Runtime": "4.0.0" + }, + "compile": { + "ref/dotnet/System.Text.Encoding.dll": {} + } + }, + "System.Text.Encoding.Extensions/4.0.10": { + "type": "package", + "dependencies": { + "System.Runtime": "4.0.0", + "System.Text.Encoding": "4.0.10" + }, + "compile": { + "ref/dotnet/System.Text.Encoding.Extensions.dll": {} + } + }, + "System.Text.RegularExpressions/4.0.10": { + "type": "package", + "dependencies": { + "System.Collections": "4.0.10", + "System.Globalization": "4.0.10", + "System.Resources.ResourceManager": "4.0.0", + "System.Runtime": "4.0.20", + "System.Runtime.Extensions": "4.0.10", + "System.Threading": "4.0.10" + }, + "compile": { + "ref/dotnet/System.Text.RegularExpressions.dll": {} + }, + "runtime": { + "lib/dotnet/System.Text.RegularExpressions.dll": {} + } + }, + "System.Threading/4.0.10": { + "type": "package", + "dependencies": { + "System.Runtime": "4.0.0", + "System.Threading.Tasks": "4.0.0" + }, + "compile": { + "ref/dotnet/System.Threading.dll": {} + } + }, + "System.Threading.Tasks/4.0.10": { + "type": "package", + "dependencies": { + "System.Runtime": "4.0.0" + }, + "compile": { + "ref/dotnet/System.Threading.Tasks.dll": {} + } + }, + "System.Threading.Tasks.Dataflow/4.5.25": { + "type": "package", + "dependencies": { + "System.Collections": "4.0.0", + "System.Collections.Concurrent": "4.0.0", + "System.Diagnostics.Debug": "4.0.0", + "System.Diagnostics.Tracing": "4.0.0", + "System.Dynamic.Runtime": "4.0.0", + "System.Linq": "4.0.0", + "System.Resources.ResourceManager": "4.0.0", + "System.Runtime": "4.0.0", + "System.Runtime.Extensions": "4.0.0", + "System.Threading": "4.0.0", + "System.Threading.Tasks": "4.0.0" + }, + "compile": { + "lib/dotnet/System.Threading.Tasks.Dataflow.dll": {} + }, + "runtime": { + "lib/dotnet/System.Threading.Tasks.Dataflow.dll": {} + } + }, + "System.Threading.Tasks.Parallel/4.0.0": { + "type": "package", + "dependencies": { + "System.Collections.Concurrent": "4.0.10", + "System.Diagnostics.Debug": "4.0.10", + "System.Diagnostics.Tracing": "4.0.20", + "System.Resources.ResourceManager": "4.0.0", + "System.Runtime": "4.0.20", + "System.Runtime.Extensions": "4.0.10", + "System.Threading": "4.0.10", + "System.Threading.Tasks": "4.0.10" + }, + "compile": { + "ref/dotnet/System.Threading.Tasks.Parallel.dll": {} + }, + "runtime": { + "lib/dotnet/System.Threading.Tasks.Parallel.dll": {} + } + }, + "System.Threading.Timer/4.0.0": { + "type": "package", + "dependencies": { + "System.Runtime": "4.0.0" + }, + "compile": { + "ref/dotnet/System.Threading.Timer.dll": {} + } + }, + "System.Xml.ReaderWriter/4.0.10": { + "type": "package", + "dependencies": { + "System.Collections": "4.0.10", + "System.Diagnostics.Debug": "4.0.10", + "System.Globalization": "4.0.10", + "System.IO": "4.0.10", + "System.IO.FileSystem": "4.0.0", + "System.IO.FileSystem.Primitives": "4.0.0", + "System.Resources.ResourceManager": "4.0.0", + "System.Runtime": "4.0.20", + "System.Runtime.Extensions": "4.0.10", + "System.Runtime.InteropServices": "4.0.20", + "System.Text.Encoding": "4.0.10", + "System.Text.Encoding.Extensions": "4.0.10", + "System.Text.RegularExpressions": "4.0.10", + "System.Threading.Tasks": "4.0.10" + }, + "compile": { + "ref/dotnet/System.Xml.ReaderWriter.dll": {} + }, + "runtime": { + "lib/dotnet/System.Xml.ReaderWriter.dll": {} + } + }, + "System.Xml.XDocument/4.0.10": { + "type": "package", + "dependencies": { + "System.Collections": "4.0.10", + "System.Diagnostics.Debug": "4.0.10", + "System.Globalization": "4.0.10", + "System.IO": "4.0.10", + "System.Reflection": "4.0.10", + "System.Resources.ResourceManager": "4.0.0", + "System.Runtime": "4.0.20", + "System.Runtime.Extensions": "4.0.10", + "System.Text.Encoding": "4.0.10", + "System.Threading": "4.0.10", + "System.Xml.ReaderWriter": "4.0.10" + }, + "compile": { + "ref/dotnet/System.Xml.XDocument.dll": {} + }, + "runtime": { + "lib/dotnet/System.Xml.XDocument.dll": {} + } + } + }, + "DNXCore,Version=v5.0": { + "Microsoft.CSharp/4.0.0": { + "type": "package", + "dependencies": { + "System.Collections": "4.0.10", + "System.Diagnostics.Debug": "4.0.10", + "System.Dynamic.Runtime": "4.0.0", + "System.Globalization": "4.0.10", + "System.Linq": "4.0.0", + "System.Linq.Expressions": "4.0.0", + "System.ObjectModel": "4.0.10", + "System.Reflection": "4.0.10", + "System.Reflection.Extensions": "4.0.0", + "System.Reflection.Primitives": "4.0.0", + "System.Reflection.TypeExtensions": "4.0.0", + "System.Resources.ResourceManager": "4.0.0", + "System.Runtime": "4.0.20", + "System.Runtime.Extensions": "4.0.10", + "System.Runtime.InteropServices": "4.0.20", + "System.Threading": "4.0.10" + }, + "compile": { + "ref/dotnet/Microsoft.CSharp.dll": {} + }, + "runtime": { + "lib/dotnet/Microsoft.CSharp.dll": {} + } + }, + "Microsoft.NETCore/5.0.0": { + "type": "package", + "dependencies": { + "Microsoft.CSharp": "4.0.0", + "Microsoft.NETCore.Targets": "1.0.0", + "Microsoft.VisualBasic": "10.0.0", + "System.AppContext": "4.0.0", + "System.Collections": "4.0.10", + "System.Collections.Concurrent": "4.0.10", + "System.Collections.Immutable": "1.1.37", + "System.ComponentModel": "4.0.0", + "System.ComponentModel.Annotations": "4.0.10", + "System.Diagnostics.Debug": "4.0.10", + "System.Diagnostics.Tools": "4.0.0", + "System.Diagnostics.Tracing": "4.0.20", + "System.Dynamic.Runtime": "4.0.10", + "System.Globalization": "4.0.10", + "System.Globalization.Calendars": "4.0.0", + "System.Globalization.Extensions": "4.0.0", + "System.IO": "4.0.10", + "System.IO.Compression": "4.0.0", + "System.IO.Compression.ZipFile": "4.0.0", + "System.IO.FileSystem": "4.0.0", + "System.IO.FileSystem.Primitives": "4.0.0", + "System.IO.UnmanagedMemoryStream": "4.0.0", + "System.Linq": "4.0.0", + "System.Linq.Expressions": "4.0.10", + "System.Linq.Parallel": "4.0.0", + "System.Linq.Queryable": "4.0.0", + "System.Net.Http": "4.0.0", + "System.Net.NetworkInformation": "4.0.0", + "System.Net.Primitives": "4.0.10", + "System.Numerics.Vectors": "4.1.0", + "System.ObjectModel": "4.0.10", + "System.Reflection": "4.0.10", + "System.Reflection.DispatchProxy": "4.0.0", + "System.Reflection.Extensions": "4.0.0", + "System.Reflection.Metadata": "1.0.22", + "System.Reflection.Primitives": "4.0.0", + "System.Reflection.TypeExtensions": "4.0.0", + "System.Resources.ResourceManager": "4.0.0", + "System.Runtime": "4.0.20", + "System.Runtime.Extensions": "4.0.10", + "System.Runtime.Handles": "4.0.0", + "System.Runtime.InteropServices": "4.0.20", + "System.Runtime.Numerics": "4.0.0", + "System.Security.Claims": "4.0.0", + "System.Security.Principal": "4.0.0", + "System.Text.Encoding": "4.0.10", + "System.Text.Encoding.Extensions": "4.0.10", + "System.Text.RegularExpressions": "4.0.10", + "System.Threading": "4.0.10", + "System.Threading.Tasks": "4.0.10", + "System.Threading.Tasks.Dataflow": "4.5.25", + "System.Threading.Tasks.Parallel": "4.0.0", + "System.Threading.Timer": "4.0.0", + "System.Xml.ReaderWriter": "4.0.10", + "System.Xml.XDocument": "4.0.10" + } + }, + "Microsoft.NETCore.Platforms/1.0.0": { + "type": "package" + }, + "Microsoft.NETCore.Portable.Compatibility/1.0.0": { + "type": "package", + "dependencies": { + "Microsoft.NETCore.Runtime": "1.0.0" + }, + "compile": { + "ref/dotnet/System.ComponentModel.DataAnnotations.dll": {}, + "ref/dotnet/System.Core.dll": {}, + "ref/dotnet/System.Net.dll": {}, + "ref/dotnet/System.Numerics.dll": {}, + "ref/dotnet/System.Runtime.Serialization.dll": {}, + "ref/dotnet/System.ServiceModel.Web.dll": {}, + "ref/dotnet/System.ServiceModel.dll": {}, + "ref/dotnet/System.Windows.dll": {}, + "ref/dotnet/System.Xml.Linq.dll": {}, + "ref/dotnet/System.Xml.Serialization.dll": {}, + "ref/dotnet/System.Xml.dll": {}, + "ref/dotnet/System.dll": {}, + "ref/dotnet/mscorlib.dll": {} + }, + "runtime": { + "lib/dnxcore50/System.ComponentModel.DataAnnotations.dll": {}, + "lib/dnxcore50/System.Core.dll": {}, + "lib/dnxcore50/System.Net.dll": {}, + "lib/dnxcore50/System.Numerics.dll": {}, + "lib/dnxcore50/System.Runtime.Serialization.dll": {}, + "lib/dnxcore50/System.ServiceModel.Web.dll": {}, + "lib/dnxcore50/System.ServiceModel.dll": {}, + "lib/dnxcore50/System.Windows.dll": {}, + "lib/dnxcore50/System.Xml.Linq.dll": {}, + "lib/dnxcore50/System.Xml.Serialization.dll": {}, + "lib/dnxcore50/System.Xml.dll": {}, + "lib/dnxcore50/System.dll": {} + } + }, + "Microsoft.NETCore.Runtime/1.0.0": { + "type": "package" + }, + "Microsoft.NETCore.Targets/1.0.0": { + "type": "package", + "dependencies": { + "Microsoft.NETCore.Platforms": "1.0.0", + "Microsoft.NETCore.Targets.DNXCore": "4.9.0" + } + }, + "Microsoft.NETCore.Targets.DNXCore/4.9.0": { + "type": "package" + }, + "Microsoft.VisualBasic/10.0.0": { + "type": "package", + "dependencies": { + "System.Collections": "4.0.10", + "System.Diagnostics.Debug": "4.0.10", + "System.Dynamic.Runtime": "4.0.10", + "System.Globalization": "4.0.10", + "System.Linq": "4.0.0", + "System.Linq.Expressions": "4.0.10", + "System.ObjectModel": "4.0.10", + "System.Reflection": "4.0.10", + "System.Reflection.Extensions": "4.0.0", + "System.Reflection.Primitives": "4.0.0", + "System.Reflection.TypeExtensions": "4.0.0", + "System.Resources.ResourceManager": "4.0.0", + "System.Runtime": "4.0.20", + "System.Runtime.Extensions": "4.0.10", + "System.Runtime.InteropServices": "4.0.20", + "System.Threading": "4.0.10" + }, + "compile": { + "ref/dotnet/Microsoft.VisualBasic.dll": {} + }, + "runtime": { + "lib/dotnet/Microsoft.VisualBasic.dll": {} + } + }, + "Microsoft.Win32.Primitives/4.0.0": { + "type": "package", + "dependencies": { + "System.Runtime": "4.0.20", + "System.Runtime.InteropServices": "4.0.20" + }, + "compile": { + "ref/dotnet/Microsoft.Win32.Primitives.dll": {} + }, + "runtime": { + "lib/dotnet/Microsoft.Win32.Primitives.dll": {} + } + }, + "System.AppContext/4.0.0": { + "type": "package", + "dependencies": { + "System.Runtime": "4.0.0" + }, + "compile": { + "ref/dotnet/System.AppContext.dll": {} + }, + "runtime": { + "lib/DNXCore50/System.AppContext.dll": {} + } + }, + "System.Collections/4.0.10": { + "type": "package", + "dependencies": { + "System.Runtime": "4.0.20" + }, + "compile": { + "ref/dotnet/System.Collections.dll": {} + }, + "runtime": { + "lib/DNXCore50/System.Collections.dll": {} + } + }, + "System.Collections.Concurrent/4.0.10": { + "type": "package", + "dependencies": { + "System.Collections": "4.0.10", + "System.Diagnostics.Debug": "4.0.10", + "System.Diagnostics.Tracing": "4.0.20", + "System.Globalization": "4.0.10", + "System.Resources.ResourceManager": "4.0.0", + "System.Runtime": "4.0.20", + "System.Runtime.Extensions": "4.0.10", + "System.Threading": "4.0.10", + "System.Threading.Tasks": "4.0.10" + }, + "compile": { + "ref/dotnet/System.Collections.Concurrent.dll": {} + }, + "runtime": { + "lib/dotnet/System.Collections.Concurrent.dll": {} + } + }, + "System.Collections.Immutable/1.1.37": { + "type": "package", + "dependencies": { + "System.Collections": "4.0.0", + "System.Diagnostics.Debug": "4.0.0", + "System.Globalization": "4.0.0", + "System.Linq": "4.0.0", + "System.Resources.ResourceManager": "4.0.0", + "System.Runtime": "4.0.0", + "System.Runtime.Extensions": "4.0.0", + "System.Threading": "4.0.0" + }, + "compile": { + "lib/dotnet/System.Collections.Immutable.dll": {} + }, + "runtime": { + "lib/dotnet/System.Collections.Immutable.dll": {} + } + }, + "System.Collections.NonGeneric/4.0.0": { + "type": "package", + "dependencies": { + "System.Diagnostics.Debug": "4.0.10", + "System.Globalization": "4.0.10", + "System.Resources.ResourceManager": "4.0.0", + "System.Runtime": "4.0.20", + "System.Runtime.Extensions": "4.0.10", + "System.Threading": "4.0.10" + }, + "compile": { + "ref/dotnet/System.Collections.NonGeneric.dll": {} + }, + "runtime": { + "lib/dotnet/System.Collections.NonGeneric.dll": {} + } + }, + "System.ComponentModel/4.0.0": { + "type": "package", + "dependencies": { + "System.Runtime": "4.0.20" + }, + "compile": { + "ref/dotnet/System.ComponentModel.dll": {} + }, + "runtime": { + "lib/dotnet/System.ComponentModel.dll": {} + } + }, + "System.ComponentModel.Annotations/4.0.10": { + "type": "package", + "dependencies": { + "System.Collections": "4.0.10", + "System.ComponentModel": "4.0.0", + "System.Globalization": "4.0.10", + "System.Linq": "4.0.0", + "System.Reflection": "4.0.10", + "System.Reflection.Extensions": "4.0.0", + "System.Resources.ResourceManager": "4.0.0", + "System.Runtime": "4.0.20", + "System.Runtime.Extensions": "4.0.10", + "System.Text.RegularExpressions": "4.0.10", + "System.Threading": "4.0.10" + }, + "compile": { + "ref/dotnet/System.ComponentModel.Annotations.dll": {} + }, + "runtime": { + "lib/dotnet/System.ComponentModel.Annotations.dll": {} + } + }, + "System.ComponentModel.EventBasedAsync/4.0.10": { + "type": "package", + "dependencies": { + "System.Resources.ResourceManager": "4.0.0", + "System.Runtime": "4.0.20", + "System.Threading": "4.0.10", + "System.Threading.Tasks": "4.0.10" + }, + "compile": { + "ref/dotnet/System.ComponentModel.EventBasedAsync.dll": {} + }, + "runtime": { + "lib/dotnet/System.ComponentModel.EventBasedAsync.dll": {} + } + }, + "System.Diagnostics.Debug/4.0.10": { + "type": "package", + "dependencies": { + "System.Runtime": "4.0.0" + }, + "compile": { + "ref/dotnet/System.Diagnostics.Debug.dll": {} + }, + "runtime": { + "lib/DNXCore50/System.Diagnostics.Debug.dll": {} + } + }, + "System.Diagnostics.Tools/4.0.0": { + "type": "package", + "dependencies": { + "System.Runtime": "4.0.0" + }, + "compile": { + "ref/dotnet/System.Diagnostics.Tools.dll": {} + }, + "runtime": { + "lib/DNXCore50/System.Diagnostics.Tools.dll": {} + } + }, + "System.Diagnostics.Tracing/4.0.20": { + "type": "package", + "dependencies": { + "System.Runtime": "4.0.0" + }, + "compile": { + "ref/dotnet/System.Diagnostics.Tracing.dll": {} + }, + "runtime": { + "lib/DNXCore50/System.Diagnostics.Tracing.dll": {} + } + }, + "System.Dynamic.Runtime/4.0.10": { + "type": "package", + "dependencies": { + "System.Collections": "4.0.0", + "System.Diagnostics.Debug": "4.0.0", + "System.Globalization": "4.0.0", + "System.Linq": "4.0.0", + "System.Linq.Expressions": "4.0.10", + "System.ObjectModel": "4.0.0", + "System.Reflection": "4.0.0", + "System.Reflection.Emit": "4.0.0", + "System.Reflection.Primitives": "4.0.0", + "System.Reflection.TypeExtensions": "4.0.0", + "System.Resources.ResourceManager": "4.0.0", + "System.Runtime": "4.0.20", + "System.Runtime.Extensions": "4.0.0", + "System.Threading": "4.0.0" + }, + "compile": { + "ref/dotnet/System.Dynamic.Runtime.dll": {} + }, + "runtime": { + "lib/DNXCore50/System.Dynamic.Runtime.dll": {} + } + }, + "System.Globalization/4.0.10": { + "type": "package", + "dependencies": { + "System.Runtime": "4.0.0" + }, + "compile": { + "ref/dotnet/System.Globalization.dll": {} + }, + "runtime": { + "lib/DNXCore50/System.Globalization.dll": {} + } + }, + "System.Globalization.Calendars/4.0.0": { + "type": "package", + "dependencies": { + "System.Globalization": "4.0.0", + "System.Runtime": "4.0.0" + }, + "compile": { + "ref/dotnet/System.Globalization.Calendars.dll": {} + }, + "runtime": { + "lib/DNXCore50/System.Globalization.Calendars.dll": {} + } + }, + "System.Globalization.Extensions/4.0.0": { + "type": "package", + "dependencies": { + "System.Globalization": "4.0.10", + "System.Resources.ResourceManager": "4.0.0", + "System.Runtime": "4.0.20", + "System.Runtime.Extensions": "4.0.10", + "System.Runtime.InteropServices": "4.0.20" + }, + "compile": { + "ref/dotnet/System.Globalization.Extensions.dll": {} + }, + "runtime": { + "lib/dotnet/System.Globalization.Extensions.dll": {} + } + }, + "System.IO/4.0.10": { + "type": "package", + "dependencies": { + "System.Runtime": "4.0.20", + "System.Text.Encoding": "4.0.0", + "System.Threading.Tasks": "4.0.0" + }, + "compile": { + "ref/dotnet/System.IO.dll": {} + }, + "runtime": { + "lib/DNXCore50/System.IO.dll": {} + } + }, + "System.IO.Compression/4.0.0": { + "type": "package", + "dependencies": { + "System.Collections": "4.0.0", + "System.IO": "4.0.0", + "System.Resources.ResourceManager": "4.0.0", + "System.Runtime": "4.0.0", + "System.Runtime.Extensions": "4.0.0", + "System.Runtime.InteropServices": "4.0.0", + "System.Text.Encoding": "4.0.0", + "System.Threading": "4.0.0", + "System.Threading.Tasks": "4.0.0" + }, + "compile": { + "ref/dotnet/System.IO.Compression.dll": {} + }, + "runtime": { + "lib/dotnet/System.IO.Compression.dll": {} + } + }, + "System.IO.Compression.ZipFile/4.0.0": { + "type": "package", + "dependencies": { + "System.IO": "4.0.10", + "System.IO.Compression": "4.0.0", + "System.IO.FileSystem": "4.0.0", + "System.IO.FileSystem.Primitives": "4.0.0", + "System.Resources.ResourceManager": "4.0.0", + "System.Runtime": "4.0.20", + "System.Runtime.Extensions": "4.0.10", + "System.Text.Encoding": "4.0.10" + }, + "compile": { + "ref/dotnet/System.IO.Compression.ZipFile.dll": {} + }, + "runtime": { + "lib/dotnet/System.IO.Compression.ZipFile.dll": {} + } + }, + "System.IO.FileSystem/4.0.0": { + "type": "package", + "dependencies": { + "System.Collections": "4.0.10", + "System.IO": "4.0.10", + "System.IO.FileSystem.Primitives": "4.0.0", + "System.Resources.ResourceManager": "4.0.0", + "System.Runtime": "4.0.20", + "System.Runtime.Extensions": "4.0.10", + "System.Runtime.Handles": "4.0.0", + "System.Runtime.InteropServices": "4.0.20", + "System.Text.Encoding": "4.0.10", + "System.Text.Encoding.Extensions": "4.0.10", + "System.Threading": "4.0.10", + "System.Threading.Overlapped": "4.0.0", + "System.Threading.Tasks": "4.0.10" + }, + "compile": { + "ref/dotnet/System.IO.FileSystem.dll": {} + }, + "runtime": { + "lib/DNXCore50/System.IO.FileSystem.dll": {} + } + }, + "System.IO.FileSystem.Primitives/4.0.0": { + "type": "package", + "dependencies": { + "System.Runtime": "4.0.20" + }, + "compile": { + "ref/dotnet/System.IO.FileSystem.Primitives.dll": {} + }, + "runtime": { + "lib/dotnet/System.IO.FileSystem.Primitives.dll": {} + } + }, + "System.IO.UnmanagedMemoryStream/4.0.0": { + "type": "package", + "dependencies": { + "System.IO": "4.0.10", + "System.IO.FileSystem.Primitives": "4.0.0", + "System.Resources.ResourceManager": "4.0.0", + "System.Runtime": "4.0.20", + "System.Runtime.InteropServices": "4.0.20", + "System.Threading": "4.0.10", + "System.Threading.Tasks": "4.0.10" + }, + "compile": { + "ref/dotnet/System.IO.UnmanagedMemoryStream.dll": {} + }, + "runtime": { + "lib/dotnet/System.IO.UnmanagedMemoryStream.dll": {} + } + }, + "System.Linq/4.0.0": { + "type": "package", + "dependencies": { + "System.Collections": "4.0.10", + "System.Diagnostics.Debug": "4.0.10", + "System.Resources.ResourceManager": "4.0.0", + "System.Runtime": "4.0.20", + "System.Runtime.Extensions": "4.0.10" + }, + "compile": { + "ref/dotnet/System.Linq.dll": {} + }, + "runtime": { + "lib/dotnet/System.Linq.dll": {} + } + }, + "System.Linq.Expressions/4.0.10": { + "type": "package", + "dependencies": { + "System.Collections": "4.0.0", + "System.Diagnostics.Debug": "4.0.0", + "System.Globalization": "4.0.0", + "System.IO": "4.0.0", + "System.Linq": "4.0.0", + "System.ObjectModel": "4.0.0", + "System.Reflection": "4.0.0", + "System.Reflection.Emit": "4.0.0", + "System.Reflection.Extensions": "4.0.0", + "System.Reflection.Primitives": "4.0.0", + "System.Reflection.TypeExtensions": "4.0.0", + "System.Resources.ResourceManager": "4.0.0", + "System.Runtime": "4.0.20", + "System.Runtime.Extensions": "4.0.0", + "System.Threading": "4.0.0" + }, + "compile": { + "ref/dotnet/System.Linq.Expressions.dll": {} + }, + "runtime": { + "lib/DNXCore50/System.Linq.Expressions.dll": {} + } + }, + "System.Linq.Parallel/4.0.0": { + "type": "package", + "dependencies": { + "System.Collections": "4.0.10", + "System.Collections.Concurrent": "4.0.10", + "System.Diagnostics.Debug": "4.0.10", + "System.Diagnostics.Tracing": "4.0.20", + "System.Linq": "4.0.0", + "System.Resources.ResourceManager": "4.0.0", + "System.Runtime": "4.0.20", + "System.Runtime.Extensions": "4.0.10", + "System.Threading": "4.0.10", + "System.Threading.Tasks": "4.0.10" + }, + "compile": { + "ref/dotnet/System.Linq.Parallel.dll": {} + }, + "runtime": { + "lib/dotnet/System.Linq.Parallel.dll": {} + } + }, + "System.Linq.Queryable/4.0.0": { + "type": "package", + "dependencies": { + "System.Collections": "4.0.10", + "System.Linq": "4.0.0", + "System.Linq.Expressions": "4.0.10", + "System.Reflection": "4.0.10", + "System.Reflection.Extensions": "4.0.0", + "System.Resources.ResourceManager": "4.0.0", + "System.Runtime": "4.0.20" + }, + "compile": { + "ref/dotnet/System.Linq.Queryable.dll": {} + }, + "runtime": { + "lib/dotnet/System.Linq.Queryable.dll": {} + } + }, + "System.Net.Http/4.0.0": { + "type": "package", + "dependencies": { + "Microsoft.Win32.Primitives": "4.0.0", + "System.Collections": "4.0.10", + "System.Diagnostics.Debug": "4.0.10", + "System.Globalization": "4.0.10", + "System.IO": "4.0.10", + "System.IO.Compression": "4.0.0", + "System.Net.Primitives": "4.0.10", + "System.Resources.ResourceManager": "4.0.0", + "System.Runtime": "4.0.20", + "System.Runtime.Extensions": "4.0.10", + "System.Runtime.Handles": "4.0.0", + "System.Runtime.InteropServices": "4.0.20", + "System.Text.Encoding": "4.0.10", + "System.Threading": "4.0.10", + "System.Threading.Tasks": "4.0.10" + }, + "compile": { + "ref/dotnet/System.Net.Http.dll": {} + }, + "runtime": { + "lib/DNXCore50/System.Net.Http.dll": {} + } + }, + "System.Net.NetworkInformation/4.0.0": { + "type": "package", + "dependencies": { + "System.Runtime": "4.0.0" + }, + "compile": { + "ref/dotnet/System.Net.NetworkInformation.dll": {} + } + }, + "System.Net.Primitives/4.0.10": { + "type": "package", + "dependencies": { + "System.Private.Networking": "4.0.0" + }, + "compile": { + "ref/dotnet/System.Net.Primitives.dll": {} + }, + "runtime": { + "lib/DNXCore50/System.Net.Primitives.dll": {} + } + }, + "System.Numerics.Vectors/4.1.0": { + "type": "package", + "dependencies": { + "System.Globalization": "4.0.10", + "System.Resources.ResourceManager": "4.0.0", + "System.Runtime": "4.0.20", + "System.Runtime.Extensions": "4.0.10" + }, + "compile": { + "ref/dotnet/System.Numerics.Vectors.dll": {} + }, + "runtime": { + "lib/dotnet/System.Numerics.Vectors.dll": {} + } + }, + "System.ObjectModel/4.0.10": { + "type": "package", + "dependencies": { + "System.Collections": "4.0.10", + "System.Diagnostics.Debug": "4.0.10", + "System.Resources.ResourceManager": "4.0.0", + "System.Runtime": "4.0.20", + "System.Threading": "4.0.10" + }, + "compile": { + "ref/dotnet/System.ObjectModel.dll": {} + }, + "runtime": { + "lib/dotnet/System.ObjectModel.dll": {} + } + }, + "System.Private.Networking/4.0.0": { + "type": "package", + "dependencies": { + "Microsoft.Win32.Primitives": "4.0.0", + "System.Collections": "4.0.10", + "System.Collections.Concurrent": "4.0.0", + "System.Collections.NonGeneric": "4.0.0", + "System.ComponentModel.EventBasedAsync": "4.0.10", + "System.Diagnostics.Debug": "4.0.10", + "System.Diagnostics.Tracing": "4.0.20", + "System.Globalization": "4.0.10", + "System.IO": "4.0.10", + "System.IO.FileSystem": "4.0.0", + "System.IO.FileSystem.Primitives": "4.0.0", + "System.Resources.ResourceManager": "4.0.0", + "System.Runtime": "4.0.20", + "System.Runtime.Extensions": "4.0.10", + "System.Runtime.Handles": "4.0.0", + "System.Runtime.InteropServices": "4.0.20", + "System.Threading": "4.0.10", + "System.Threading.Overlapped": "4.0.0", + "System.Threading.Tasks": "4.0.10" + }, + "compile": { + "ref/dnxcore50/_._": {} + }, + "runtime": { + "lib/DNXCore50/System.Private.Networking.dll": {} + } + }, + "System.Private.Uri/4.0.0": { + "type": "package", + "compile": { + "ref/dnxcore50/_._": {} + }, + "runtime": { + "lib/DNXCore50/System.Private.Uri.dll": {} + } + }, + "System.Reflection/4.0.10": { + "type": "package", + "dependencies": { + "System.IO": "4.0.0", + "System.Reflection.Primitives": "4.0.0", + "System.Runtime": "4.0.20" + }, + "compile": { + "ref/dotnet/System.Reflection.dll": {} + }, + "runtime": { + "lib/DNXCore50/System.Reflection.dll": {} + } + }, + "System.Reflection.DispatchProxy/4.0.0": { + "type": "package", + "dependencies": { + "System.Collections": "4.0.10", + "System.Linq": "4.0.0", + "System.Reflection": "4.0.10", + "System.Reflection.Extensions": "4.0.0", + "System.Reflection.Primitives": "4.0.0", + "System.Resources.ResourceManager": "4.0.0", + "System.Runtime": "4.0.20", + "System.Threading": "4.0.10" + }, + "compile": { + "ref/dotnet/System.Reflection.DispatchProxy.dll": {} + }, + "runtime": { + "lib/DNXCore50/System.Reflection.DispatchProxy.dll": {} + } + }, + "System.Reflection.Emit/4.0.0": { + "type": "package", + "dependencies": { + "System.IO": "4.0.0", + "System.Reflection": "4.0.0", + "System.Reflection.Emit.ILGeneration": "4.0.0", + "System.Reflection.Primitives": "4.0.0", + "System.Runtime": "4.0.0" + }, + "compile": { + "ref/dotnet/System.Reflection.Emit.dll": {} + }, + "runtime": { + "lib/DNXCore50/System.Reflection.Emit.dll": {} + } + }, + "System.Reflection.Emit.ILGeneration/4.0.0": { + "type": "package", + "dependencies": { + "System.Reflection": "4.0.0", + "System.Reflection.Primitives": "4.0.0", + "System.Runtime": "4.0.0" + }, + "compile": { + "ref/dotnet/System.Reflection.Emit.ILGeneration.dll": {} + }, + "runtime": { + "lib/DNXCore50/System.Reflection.Emit.ILGeneration.dll": {} + } + }, + "System.Reflection.Extensions/4.0.0": { + "type": "package", + "dependencies": { + "System.Reflection": "4.0.0", + "System.Runtime": "4.0.0" + }, + "compile": { + "ref/dotnet/System.Reflection.Extensions.dll": {} + }, + "runtime": { + "lib/DNXCore50/System.Reflection.Extensions.dll": {} + } + }, + "System.Reflection.Metadata/1.0.22": { + "type": "package", + "dependencies": { + "System.Collections": "4.0.0", + "System.Collections.Immutable": "1.1.37", + "System.Diagnostics.Debug": "4.0.0", + "System.IO": "4.0.0", + "System.Reflection": "4.0.0", + "System.Reflection.Extensions": "4.0.0", + "System.Reflection.Primitives": "4.0.0", + "System.Resources.ResourceManager": "4.0.0", + "System.Runtime": "4.0.0", + "System.Runtime.Extensions": "4.0.0", + "System.Runtime.InteropServices": "4.0.0", + "System.Text.Encoding": "4.0.0", + "System.Text.Encoding.Extensions": "4.0.0", + "System.Threading": "4.0.0" + }, + "compile": { + "lib/dotnet/System.Reflection.Metadata.dll": {} + }, + "runtime": { + "lib/dotnet/System.Reflection.Metadata.dll": {} + } + }, + "System.Reflection.Primitives/4.0.0": { + "type": "package", + "dependencies": { + "System.Runtime": "4.0.0" + }, + "compile": { + "ref/dotnet/System.Reflection.Primitives.dll": {} + }, + "runtime": { + "lib/DNXCore50/System.Reflection.Primitives.dll": {} + } + }, + "System.Reflection.TypeExtensions/4.0.0": { + "type": "package", + "dependencies": { + "System.Reflection": "4.0.0", + "System.Runtime": "4.0.0" + }, + "compile": { + "ref/dotnet/System.Reflection.TypeExtensions.dll": {} + }, + "runtime": { + "lib/DNXCore50/System.Reflection.TypeExtensions.dll": {} + } + }, + "System.Resources.ResourceManager/4.0.0": { + "type": "package", + "dependencies": { + "System.Globalization": "4.0.0", + "System.Reflection": "4.0.0", + "System.Runtime": "4.0.0" + }, + "compile": { + "ref/dotnet/System.Resources.ResourceManager.dll": {} + }, + "runtime": { + "lib/DNXCore50/System.Resources.ResourceManager.dll": {} + } + }, + "System.Runtime/4.0.20": { + "type": "package", + "dependencies": { + "System.Private.Uri": "4.0.0" + }, + "compile": { + "ref/dotnet/System.Runtime.dll": {} + }, + "runtime": { + "lib/DNXCore50/System.Runtime.dll": {} + } + }, + "System.Runtime.Extensions/4.0.10": { + "type": "package", + "dependencies": { + "System.Runtime": "4.0.20" + }, + "compile": { + "ref/dotnet/System.Runtime.Extensions.dll": {} + }, + "runtime": { + "lib/DNXCore50/System.Runtime.Extensions.dll": {} + } + }, + "System.Runtime.Handles/4.0.0": { + "type": "package", + "dependencies": { + "System.Runtime": "4.0.0" + }, + "compile": { + "ref/dotnet/System.Runtime.Handles.dll": {} + }, + "runtime": { + "lib/DNXCore50/System.Runtime.Handles.dll": {} + } + }, + "System.Runtime.InteropServices/4.0.20": { + "type": "package", + "dependencies": { + "System.Reflection": "4.0.0", + "System.Reflection.Primitives": "4.0.0", + "System.Runtime": "4.0.0", + "System.Runtime.Handles": "4.0.0" + }, + "compile": { + "ref/dotnet/System.Runtime.InteropServices.dll": {} + }, + "runtime": { + "lib/DNXCore50/System.Runtime.InteropServices.dll": {} + } + }, + "System.Runtime.Numerics/4.0.0": { + "type": "package", + "dependencies": { + "System.Globalization": "4.0.10", + "System.Resources.ResourceManager": "4.0.0", + "System.Runtime": "4.0.20", + "System.Runtime.Extensions": "4.0.10" + }, + "compile": { + "ref/dotnet/System.Runtime.Numerics.dll": {} + }, + "runtime": { + "lib/dotnet/System.Runtime.Numerics.dll": {} + } + }, + "System.Security.Claims/4.0.0": { + "type": "package", + "dependencies": { + "System.Collections": "4.0.0", + "System.Diagnostics.Debug": "4.0.0", + "System.Globalization": "4.0.0", + "System.IO": "4.0.0", + "System.Resources.ResourceManager": "4.0.0", + "System.Runtime": "4.0.20", + "System.Runtime.Extensions": "4.0.0", + "System.Security.Principal": "4.0.0" + }, + "compile": { + "ref/dotnet/System.Security.Claims.dll": {} + }, + "runtime": { + "lib/dotnet/System.Security.Claims.dll": {} + } + }, + "System.Security.Principal/4.0.0": { + "type": "package", + "dependencies": { + "System.Runtime": "4.0.0" + }, + "compile": { + "ref/dotnet/System.Security.Principal.dll": {} + }, + "runtime": { + "lib/dotnet/System.Security.Principal.dll": {} + } + }, + "System.Text.Encoding/4.0.10": { + "type": "package", + "dependencies": { + "System.Runtime": "4.0.0" + }, + "compile": { + "ref/dotnet/System.Text.Encoding.dll": {} + }, + "runtime": { + "lib/DNXCore50/System.Text.Encoding.dll": {} + } + }, + "System.Text.Encoding.Extensions/4.0.10": { + "type": "package", + "dependencies": { + "System.Runtime": "4.0.0", + "System.Text.Encoding": "4.0.10" + }, + "compile": { + "ref/dotnet/System.Text.Encoding.Extensions.dll": {} + }, + "runtime": { + "lib/DNXCore50/System.Text.Encoding.Extensions.dll": {} + } + }, + "System.Text.RegularExpressions/4.0.10": { + "type": "package", + "dependencies": { + "System.Collections": "4.0.10", + "System.Globalization": "4.0.10", + "System.Resources.ResourceManager": "4.0.0", + "System.Runtime": "4.0.20", + "System.Runtime.Extensions": "4.0.10", + "System.Threading": "4.0.10" + }, + "compile": { + "ref/dotnet/System.Text.RegularExpressions.dll": {} + }, + "runtime": { + "lib/dotnet/System.Text.RegularExpressions.dll": {} + } + }, + "System.Threading/4.0.10": { + "type": "package", + "dependencies": { + "System.Runtime": "4.0.0", + "System.Threading.Tasks": "4.0.0" + }, + "compile": { + "ref/dotnet/System.Threading.dll": {} + }, + "runtime": { + "lib/DNXCore50/System.Threading.dll": {} + } + }, + "System.Threading.Overlapped/4.0.0": { + "type": "package", + "dependencies": { + "System.Runtime": "4.0.0", + "System.Runtime.Handles": "4.0.0" + }, + "compile": { + "ref/dotnet/System.Threading.Overlapped.dll": {} + }, + "runtime": { + "lib/DNXCore50/System.Threading.Overlapped.dll": {} + } + }, + "System.Threading.Tasks/4.0.10": { + "type": "package", + "dependencies": { + "System.Runtime": "4.0.0" + }, + "compile": { + "ref/dotnet/System.Threading.Tasks.dll": {} + }, + "runtime": { + "lib/DNXCore50/System.Threading.Tasks.dll": {} + } + }, + "System.Threading.Tasks.Dataflow/4.5.25": { + "type": "package", + "dependencies": { + "System.Collections": "4.0.0", + "System.Collections.Concurrent": "4.0.0", + "System.Diagnostics.Debug": "4.0.0", + "System.Diagnostics.Tracing": "4.0.0", + "System.Dynamic.Runtime": "4.0.0", + "System.Linq": "4.0.0", + "System.Resources.ResourceManager": "4.0.0", + "System.Runtime": "4.0.0", + "System.Runtime.Extensions": "4.0.0", + "System.Threading": "4.0.0", + "System.Threading.Tasks": "4.0.0" + }, + "compile": { + "lib/dotnet/System.Threading.Tasks.Dataflow.dll": {} + }, + "runtime": { + "lib/dotnet/System.Threading.Tasks.Dataflow.dll": {} + } + }, + "System.Threading.Tasks.Parallel/4.0.0": { + "type": "package", + "dependencies": { + "System.Collections.Concurrent": "4.0.10", + "System.Diagnostics.Debug": "4.0.10", + "System.Diagnostics.Tracing": "4.0.20", + "System.Resources.ResourceManager": "4.0.0", + "System.Runtime": "4.0.20", + "System.Runtime.Extensions": "4.0.10", + "System.Threading": "4.0.10", + "System.Threading.Tasks": "4.0.10" + }, + "compile": { + "ref/dotnet/System.Threading.Tasks.Parallel.dll": {} + }, + "runtime": { + "lib/dotnet/System.Threading.Tasks.Parallel.dll": {} + } + }, + "System.Threading.Timer/4.0.0": { + "type": "package", + "dependencies": { + "System.Runtime": "4.0.0" + }, + "compile": { + "ref/dotnet/System.Threading.Timer.dll": {} + }, + "runtime": { + "lib/DNXCore50/System.Threading.Timer.dll": {} + } + }, + "System.Xml.ReaderWriter/4.0.10": { + "type": "package", + "dependencies": { + "System.Collections": "4.0.10", + "System.Diagnostics.Debug": "4.0.10", + "System.Globalization": "4.0.10", + "System.IO": "4.0.10", + "System.IO.FileSystem": "4.0.0", + "System.IO.FileSystem.Primitives": "4.0.0", + "System.Resources.ResourceManager": "4.0.0", + "System.Runtime": "4.0.20", + "System.Runtime.Extensions": "4.0.10", + "System.Runtime.InteropServices": "4.0.20", + "System.Text.Encoding": "4.0.10", + "System.Text.Encoding.Extensions": "4.0.10", + "System.Text.RegularExpressions": "4.0.10", + "System.Threading.Tasks": "4.0.10" + }, + "compile": { + "ref/dotnet/System.Xml.ReaderWriter.dll": {} + }, + "runtime": { + "lib/dotnet/System.Xml.ReaderWriter.dll": {} + } + }, + "System.Xml.XDocument/4.0.10": { + "type": "package", + "dependencies": { + "System.Collections": "4.0.10", + "System.Diagnostics.Debug": "4.0.10", + "System.Globalization": "4.0.10", + "System.IO": "4.0.10", + "System.Reflection": "4.0.10", + "System.Resources.ResourceManager": "4.0.0", + "System.Runtime": "4.0.20", + "System.Runtime.Extensions": "4.0.10", + "System.Text.Encoding": "4.0.10", + "System.Threading": "4.0.10", + "System.Xml.ReaderWriter": "4.0.10" + }, + "compile": { + "ref/dotnet/System.Xml.XDocument.dll": {} + }, + "runtime": { + "lib/dotnet/System.Xml.XDocument.dll": {} + } + } + }, + "DNXCore,Version=v5.0/win7-x64": { + "Microsoft.CSharp/4.0.0": { + "type": "package", + "dependencies": { + "System.Collections": "4.0.10", + "System.Diagnostics.Debug": "4.0.10", + "System.Dynamic.Runtime": "4.0.0", + "System.Globalization": "4.0.10", + "System.Linq": "4.0.0", + "System.Linq.Expressions": "4.0.0", + "System.ObjectModel": "4.0.10", + "System.Reflection": "4.0.10", + "System.Reflection.Extensions": "4.0.0", + "System.Reflection.Primitives": "4.0.0", + "System.Reflection.TypeExtensions": "4.0.0", + "System.Resources.ResourceManager": "4.0.0", + "System.Runtime": "4.0.20", + "System.Runtime.Extensions": "4.0.10", + "System.Runtime.InteropServices": "4.0.20", + "System.Threading": "4.0.10" + }, + "compile": { + "ref/dotnet/Microsoft.CSharp.dll": {} + }, + "runtime": { + "lib/dotnet/Microsoft.CSharp.dll": {} + } + }, + "Microsoft.NETCore/5.0.0": { + "type": "package", + "dependencies": { + "Microsoft.CSharp": "4.0.0", + "Microsoft.NETCore.Targets": "1.0.0", + "Microsoft.VisualBasic": "10.0.0", + "System.AppContext": "4.0.0", + "System.Collections": "4.0.10", + "System.Collections.Concurrent": "4.0.10", + "System.Collections.Immutable": "1.1.37", + "System.ComponentModel": "4.0.0", + "System.ComponentModel.Annotations": "4.0.10", + "System.Diagnostics.Debug": "4.0.10", + "System.Diagnostics.Tools": "4.0.0", + "System.Diagnostics.Tracing": "4.0.20", + "System.Dynamic.Runtime": "4.0.10", + "System.Globalization": "4.0.10", + "System.Globalization.Calendars": "4.0.0", + "System.Globalization.Extensions": "4.0.0", + "System.IO": "4.0.10", + "System.IO.Compression": "4.0.0", + "System.IO.Compression.ZipFile": "4.0.0", + "System.IO.FileSystem": "4.0.0", + "System.IO.FileSystem.Primitives": "4.0.0", + "System.IO.UnmanagedMemoryStream": "4.0.0", + "System.Linq": "4.0.0", + "System.Linq.Expressions": "4.0.10", + "System.Linq.Parallel": "4.0.0", + "System.Linq.Queryable": "4.0.0", + "System.Net.Http": "4.0.0", + "System.Net.NetworkInformation": "4.0.0", + "System.Net.Primitives": "4.0.10", + "System.Numerics.Vectors": "4.1.0", + "System.ObjectModel": "4.0.10", + "System.Reflection": "4.0.10", + "System.Reflection.DispatchProxy": "4.0.0", + "System.Reflection.Extensions": "4.0.0", + "System.Reflection.Metadata": "1.0.22", + "System.Reflection.Primitives": "4.0.0", + "System.Reflection.TypeExtensions": "4.0.0", + "System.Resources.ResourceManager": "4.0.0", + "System.Runtime": "4.0.20", + "System.Runtime.Extensions": "4.0.10", + "System.Runtime.Handles": "4.0.0", + "System.Runtime.InteropServices": "4.0.20", + "System.Runtime.Numerics": "4.0.0", + "System.Security.Claims": "4.0.0", + "System.Security.Principal": "4.0.0", + "System.Text.Encoding": "4.0.10", + "System.Text.Encoding.Extensions": "4.0.10", + "System.Text.RegularExpressions": "4.0.10", + "System.Threading": "4.0.10", + "System.Threading.Tasks": "4.0.10", + "System.Threading.Tasks.Dataflow": "4.5.25", + "System.Threading.Tasks.Parallel": "4.0.0", + "System.Threading.Timer": "4.0.0", + "System.Xml.ReaderWriter": "4.0.10", + "System.Xml.XDocument": "4.0.10" + } + }, + "Microsoft.NETCore.Platforms/1.0.0": { + "type": "package" + }, + "Microsoft.NETCore.Portable.Compatibility/1.0.0": { + "type": "package", + "dependencies": { + "Microsoft.NETCore.Runtime": "1.0.0" + }, + "compile": { + "ref/dotnet/System.ComponentModel.DataAnnotations.dll": {}, + "ref/dotnet/System.Core.dll": {}, + "ref/dotnet/System.Net.dll": {}, + "ref/dotnet/System.Numerics.dll": {}, + "ref/dotnet/System.Runtime.Serialization.dll": {}, + "ref/dotnet/System.ServiceModel.Web.dll": {}, + "ref/dotnet/System.ServiceModel.dll": {}, + "ref/dotnet/System.Windows.dll": {}, + "ref/dotnet/System.Xml.Linq.dll": {}, + "ref/dotnet/System.Xml.Serialization.dll": {}, + "ref/dotnet/System.Xml.dll": {}, + "ref/dotnet/System.dll": {}, + "ref/dotnet/mscorlib.dll": {} + }, + "runtime": { + "lib/dnxcore50/System.ComponentModel.DataAnnotations.dll": {}, + "lib/dnxcore50/System.Core.dll": {}, + "lib/dnxcore50/System.Net.dll": {}, + "lib/dnxcore50/System.Numerics.dll": {}, + "lib/dnxcore50/System.Runtime.Serialization.dll": {}, + "lib/dnxcore50/System.ServiceModel.Web.dll": {}, + "lib/dnxcore50/System.ServiceModel.dll": {}, + "lib/dnxcore50/System.Windows.dll": {}, + "lib/dnxcore50/System.Xml.Linq.dll": {}, + "lib/dnxcore50/System.Xml.Serialization.dll": {}, + "lib/dnxcore50/System.Xml.dll": {}, + "lib/dnxcore50/System.dll": {} + } + }, + "Microsoft.NETCore.Runtime/1.0.0": { + "type": "package", + "dependencies": { + "Microsoft.NETCore.Runtime.CoreCLR-x64": "1.0.0", + "Microsoft.NETCore.Windows.ApiSets-x64": "1.0.0" + } + }, + "Microsoft.NETCore.Runtime.CoreCLR-x64/1.0.0": { + "type": "package", + "dependencies": { + "System.Collections": "[4.0.10]", + "System.Diagnostics.Contracts": "[4.0.0]", + "System.Diagnostics.Debug": "[4.0.10]", + "System.Diagnostics.StackTrace": "[4.0.0]", + "System.Diagnostics.Tools": "[4.0.0]", + "System.Diagnostics.Tracing": "[4.0.20]", + "System.Globalization": "[4.0.10]", + "System.Globalization.Calendars": "[4.0.0]", + "System.IO": "[4.0.10]", + "System.ObjectModel": "[4.0.10]", + "System.Private.Uri": "[4.0.0]", + "System.Reflection": "[4.0.10]", + "System.Reflection.Extensions": "[4.0.0]", + "System.Reflection.Primitives": "[4.0.0]", + "System.Resources.ResourceManager": "[4.0.0]", + "System.Runtime": "[4.0.20]", + "System.Runtime.Extensions": "[4.0.10]", + "System.Runtime.Handles": "[4.0.0]", + "System.Runtime.InteropServices": "[4.0.20]", + "System.Text.Encoding": "[4.0.10]", + "System.Text.Encoding.Extensions": "[4.0.10]", + "System.Threading": "[4.0.10]", + "System.Threading.Tasks": "[4.0.10]", + "System.Threading.Timer": "[4.0.0]" + }, + "compile": { + "ref/dotnet/_._": {} + }, + "runtime": { + "runtimes/win7-x64/lib/dotnet/mscorlib.ni.dll": {} + }, + "native": { + "runtimes/win7-x64/native/clretwrc.dll": {}, + "runtimes/win7-x64/native/coreclr.dll": {}, + "runtimes/win7-x64/native/dbgshim.dll": {}, + "runtimes/win7-x64/native/mscordaccore.dll": {}, + "runtimes/win7-x64/native/mscordbi.dll": {}, + "runtimes/win7-x64/native/mscorrc.debug.dll": {}, + "runtimes/win7-x64/native/mscorrc.dll": {} + } + }, + "Microsoft.NETCore.Targets/1.0.0": { + "type": "package", + "dependencies": { + "Microsoft.NETCore.Platforms": "1.0.0", + "Microsoft.NETCore.Targets.DNXCore": "4.9.0" + } + }, + "Microsoft.NETCore.Targets.DNXCore/4.9.0": { + "type": "package" + }, + "Microsoft.NETCore.Windows.ApiSets-x64/1.0.0": { + "type": "package", + "native": { + "runtimes/win7-x64/native/API-MS-Win-Base-Util-L1-1-0.dll": {}, + "runtimes/win7-x64/native/API-MS-Win-Core-Kernel32-Private-L1-1-0.dll": {}, + "runtimes/win7-x64/native/API-MS-Win-Core-Kernel32-Private-L1-1-1.dll": {}, + "runtimes/win7-x64/native/API-MS-Win-Core-Kernel32-Private-L1-1-2.dll": {}, + "runtimes/win7-x64/native/API-MS-Win-Core-PrivateProfile-L1-1-0.dll": {}, + "runtimes/win7-x64/native/API-MS-Win-Core-ProcessTopology-Obsolete-L1-1-0.dll": {}, + "runtimes/win7-x64/native/API-MS-Win-Core-String-L2-1-0.dll": {}, + "runtimes/win7-x64/native/API-MS-Win-Core-StringAnsi-L1-1-0.dll": {}, + "runtimes/win7-x64/native/API-MS-Win-EventLog-Legacy-L1-1-0.dll": {}, + "runtimes/win7-x64/native/API-MS-Win-Eventing-ClassicProvider-L1-1-0.dll": {}, + "runtimes/win7-x64/native/API-MS-Win-Eventing-Consumer-L1-1-0.dll": {}, + "runtimes/win7-x64/native/API-MS-Win-Eventing-Controller-L1-1-0.dll": {}, + "runtimes/win7-x64/native/API-MS-Win-Eventing-Legacy-L1-1-0.dll": {}, + "runtimes/win7-x64/native/API-MS-Win-Eventing-Provider-L1-1-0.dll": {}, + "runtimes/win7-x64/native/API-MS-Win-Security-LsaPolicy-L1-1-0.dll": {}, + "runtimes/win7-x64/native/API-MS-Win-devices-config-L1-1-0.dll": {}, + "runtimes/win7-x64/native/API-MS-Win-devices-config-L1-1-1.dll": {}, + "runtimes/win7-x64/native/api-ms-win-core-com-l1-1-0.dll": {}, + "runtimes/win7-x64/native/api-ms-win-core-com-private-l1-1-0.dll": {}, + "runtimes/win7-x64/native/api-ms-win-core-comm-l1-1-0.dll": {}, + "runtimes/win7-x64/native/api-ms-win-core-console-l1-1-0.dll": {}, + "runtimes/win7-x64/native/api-ms-win-core-console-l2-1-0.dll": {}, + "runtimes/win7-x64/native/api-ms-win-core-datetime-l1-1-0.dll": {}, + "runtimes/win7-x64/native/api-ms-win-core-datetime-l1-1-1.dll": {}, + "runtimes/win7-x64/native/api-ms-win-core-debug-l1-1-0.dll": {}, + "runtimes/win7-x64/native/api-ms-win-core-debug-l1-1-1.dll": {}, + "runtimes/win7-x64/native/api-ms-win-core-delayload-l1-1-0.dll": {}, + "runtimes/win7-x64/native/api-ms-win-core-errorhandling-l1-1-0.dll": {}, + "runtimes/win7-x64/native/api-ms-win-core-errorhandling-l1-1-1.dll": {}, + "runtimes/win7-x64/native/api-ms-win-core-fibers-l1-1-0.dll": {}, + "runtimes/win7-x64/native/api-ms-win-core-fibers-l1-1-1.dll": {}, + "runtimes/win7-x64/native/api-ms-win-core-file-l1-1-0.dll": {}, + "runtimes/win7-x64/native/api-ms-win-core-file-l1-2-0.dll": {}, + "runtimes/win7-x64/native/api-ms-win-core-file-l1-2-1.dll": {}, + "runtimes/win7-x64/native/api-ms-win-core-file-l2-1-0.dll": {}, + "runtimes/win7-x64/native/api-ms-win-core-file-l2-1-1.dll": {}, + "runtimes/win7-x64/native/api-ms-win-core-handle-l1-1-0.dll": {}, + "runtimes/win7-x64/native/api-ms-win-core-heap-l1-1-0.dll": {}, + "runtimes/win7-x64/native/api-ms-win-core-heap-obsolete-l1-1-0.dll": {}, + "runtimes/win7-x64/native/api-ms-win-core-interlocked-l1-1-0.dll": {}, + "runtimes/win7-x64/native/api-ms-win-core-io-l1-1-0.dll": {}, + "runtimes/win7-x64/native/api-ms-win-core-io-l1-1-1.dll": {}, + "runtimes/win7-x64/native/api-ms-win-core-kernel32-legacy-l1-1-0.dll": {}, + "runtimes/win7-x64/native/api-ms-win-core-kernel32-legacy-l1-1-1.dll": {}, + "runtimes/win7-x64/native/api-ms-win-core-kernel32-legacy-l1-1-2.dll": {}, + "runtimes/win7-x64/native/api-ms-win-core-libraryloader-l1-1-0.dll": {}, + "runtimes/win7-x64/native/api-ms-win-core-libraryloader-l1-1-1.dll": {}, + "runtimes/win7-x64/native/api-ms-win-core-localization-l1-2-0.dll": {}, + "runtimes/win7-x64/native/api-ms-win-core-localization-l1-2-1.dll": {}, + "runtimes/win7-x64/native/api-ms-win-core-localization-l2-1-0.dll": {}, + "runtimes/win7-x64/native/api-ms-win-core-localization-obsolete-l1-2-0.dll": {}, + "runtimes/win7-x64/native/api-ms-win-core-memory-l1-1-0.dll": {}, + "runtimes/win7-x64/native/api-ms-win-core-memory-l1-1-1.dll": {}, + "runtimes/win7-x64/native/api-ms-win-core-memory-l1-1-2.dll": {}, + "runtimes/win7-x64/native/api-ms-win-core-memory-l1-1-3.dll": {}, + "runtimes/win7-x64/native/api-ms-win-core-namedpipe-l1-1-0.dll": {}, + "runtimes/win7-x64/native/api-ms-win-core-namedpipe-l1-2-1.dll": {}, + "runtimes/win7-x64/native/api-ms-win-core-normalization-l1-1-0.dll": {}, + "runtimes/win7-x64/native/api-ms-win-core-privateprofile-l1-1-1.dll": {}, + "runtimes/win7-x64/native/api-ms-win-core-processenvironment-l1-1-0.dll": {}, + "runtimes/win7-x64/native/api-ms-win-core-processenvironment-l1-2-0.dll": {}, + "runtimes/win7-x64/native/api-ms-win-core-processsecurity-l1-1-0.dll": {}, + "runtimes/win7-x64/native/api-ms-win-core-processthreads-l1-1-0.dll": {}, + "runtimes/win7-x64/native/api-ms-win-core-processthreads-l1-1-1.dll": {}, + "runtimes/win7-x64/native/api-ms-win-core-processthreads-l1-1-2.dll": {}, + "runtimes/win7-x64/native/api-ms-win-core-profile-l1-1-0.dll": {}, + "runtimes/win7-x64/native/api-ms-win-core-psapi-ansi-l1-1-0.dll": {}, + "runtimes/win7-x64/native/api-ms-win-core-psapi-l1-1-0.dll": {}, + "runtimes/win7-x64/native/api-ms-win-core-psapi-obsolete-l1-1-0.dll": {}, + "runtimes/win7-x64/native/api-ms-win-core-realtime-l1-1-0.dll": {}, + "runtimes/win7-x64/native/api-ms-win-core-registry-l1-1-0.dll": {}, + "runtimes/win7-x64/native/api-ms-win-core-registry-l2-1-0.dll": {}, + "runtimes/win7-x64/native/api-ms-win-core-rtlsupport-l1-1-0.dll": {}, + "runtimes/win7-x64/native/api-ms-win-core-shlwapi-legacy-l1-1-0.dll": {}, + "runtimes/win7-x64/native/api-ms-win-core-shlwapi-obsolete-l1-1-0.dll": {}, + "runtimes/win7-x64/native/api-ms-win-core-shutdown-l1-1-0.dll": {}, + "runtimes/win7-x64/native/api-ms-win-core-shutdown-l1-1-1.dll": {}, + "runtimes/win7-x64/native/api-ms-win-core-string-l1-1-0.dll": {}, + "runtimes/win7-x64/native/api-ms-win-core-string-obsolete-l1-1-0.dll": {}, + "runtimes/win7-x64/native/api-ms-win-core-string-obsolete-l1-1-1.dll": {}, + "runtimes/win7-x64/native/api-ms-win-core-stringloader-l1-1-0.dll": {}, + "runtimes/win7-x64/native/api-ms-win-core-stringloader-l1-1-1.dll": {}, + "runtimes/win7-x64/native/api-ms-win-core-synch-l1-1-0.dll": {}, + "runtimes/win7-x64/native/api-ms-win-core-synch-l1-2-0.dll": {}, + "runtimes/win7-x64/native/api-ms-win-core-sysinfo-l1-1-0.dll": {}, + "runtimes/win7-x64/native/api-ms-win-core-sysinfo-l1-2-0.dll": {}, + "runtimes/win7-x64/native/api-ms-win-core-sysinfo-l1-2-1.dll": {}, + "runtimes/win7-x64/native/api-ms-win-core-sysinfo-l1-2-2.dll": {}, + "runtimes/win7-x64/native/api-ms-win-core-sysinfo-l1-2-3.dll": {}, + "runtimes/win7-x64/native/api-ms-win-core-threadpool-l1-2-0.dll": {}, + "runtimes/win7-x64/native/api-ms-win-core-threadpool-legacy-l1-1-0.dll": {}, + "runtimes/win7-x64/native/api-ms-win-core-threadpool-private-l1-1-0.dll": {}, + "runtimes/win7-x64/native/api-ms-win-core-timezone-l1-1-0.dll": {}, + "runtimes/win7-x64/native/api-ms-win-core-url-l1-1-0.dll": {}, + "runtimes/win7-x64/native/api-ms-win-core-util-l1-1-0.dll": {}, + "runtimes/win7-x64/native/api-ms-win-core-version-l1-1-0.dll": {}, + "runtimes/win7-x64/native/api-ms-win-core-winrt-error-l1-1-0.dll": {}, + "runtimes/win7-x64/native/api-ms-win-core-winrt-error-l1-1-1.dll": {}, + "runtimes/win7-x64/native/api-ms-win-core-winrt-l1-1-0.dll": {}, + "runtimes/win7-x64/native/api-ms-win-core-winrt-registration-l1-1-0.dll": {}, + "runtimes/win7-x64/native/api-ms-win-core-winrt-robuffer-l1-1-0.dll": {}, + "runtimes/win7-x64/native/api-ms-win-core-winrt-roparameterizediid-l1-1-0.dll": {}, + "runtimes/win7-x64/native/api-ms-win-core-winrt-string-l1-1-0.dll": {}, + "runtimes/win7-x64/native/api-ms-win-core-wow64-l1-1-0.dll": {}, + "runtimes/win7-x64/native/api-ms-win-core-xstate-l1-1-0.dll": {}, + "runtimes/win7-x64/native/api-ms-win-core-xstate-l2-1-0.dll": {}, + "runtimes/win7-x64/native/api-ms-win-ro-typeresolution-l1-1-0.dll": {}, + "runtimes/win7-x64/native/api-ms-win-security-base-l1-1-0.dll": {}, + "runtimes/win7-x64/native/api-ms-win-security-cpwl-l1-1-0.dll": {}, + "runtimes/win7-x64/native/api-ms-win-security-cryptoapi-l1-1-0.dll": {}, + "runtimes/win7-x64/native/api-ms-win-security-lsalookup-l2-1-0.dll": {}, + "runtimes/win7-x64/native/api-ms-win-security-lsalookup-l2-1-1.dll": {}, + "runtimes/win7-x64/native/api-ms-win-security-provider-l1-1-0.dll": {}, + "runtimes/win7-x64/native/api-ms-win-security-sddl-l1-1-0.dll": {}, + "runtimes/win7-x64/native/api-ms-win-service-core-l1-1-0.dll": {}, + "runtimes/win7-x64/native/api-ms-win-service-core-l1-1-1.dll": {}, + "runtimes/win7-x64/native/api-ms-win-service-management-l1-1-0.dll": {}, + "runtimes/win7-x64/native/api-ms-win-service-management-l2-1-0.dll": {}, + "runtimes/win7-x64/native/api-ms-win-service-private-l1-1-0.dll": {}, + "runtimes/win7-x64/native/api-ms-win-service-private-l1-1-1.dll": {}, + "runtimes/win7-x64/native/api-ms-win-service-winsvc-l1-1-0.dll": {}, + "runtimes/win7-x64/native/ext-ms-win-advapi32-encryptedfile-l1-1-0.dll": {} + } + }, + "Microsoft.VisualBasic/10.0.0": { + "type": "package", + "dependencies": { + "System.Collections": "4.0.10", + "System.Diagnostics.Debug": "4.0.10", + "System.Dynamic.Runtime": "4.0.10", + "System.Globalization": "4.0.10", + "System.Linq": "4.0.0", + "System.Linq.Expressions": "4.0.10", + "System.ObjectModel": "4.0.10", + "System.Reflection": "4.0.10", + "System.Reflection.Extensions": "4.0.0", + "System.Reflection.Primitives": "4.0.0", + "System.Reflection.TypeExtensions": "4.0.0", + "System.Resources.ResourceManager": "4.0.0", + "System.Runtime": "4.0.20", + "System.Runtime.Extensions": "4.0.10", + "System.Runtime.InteropServices": "4.0.20", + "System.Threading": "4.0.10" + }, + "compile": { + "ref/dotnet/Microsoft.VisualBasic.dll": {} + }, + "runtime": { + "lib/dotnet/Microsoft.VisualBasic.dll": {} + } + }, + "Microsoft.Win32.Primitives/4.0.0": { + "type": "package", + "dependencies": { + "System.Runtime": "4.0.20", + "System.Runtime.InteropServices": "4.0.20" + }, + "compile": { + "ref/dotnet/Microsoft.Win32.Primitives.dll": {} + }, + "runtime": { + "lib/dotnet/Microsoft.Win32.Primitives.dll": {} + } + }, + "System.AppContext/4.0.0": { + "type": "package", + "dependencies": { + "System.Runtime": "4.0.0" + }, + "compile": { + "ref/dotnet/System.AppContext.dll": {} + }, + "runtime": { + "lib/DNXCore50/System.AppContext.dll": {} + } + }, + "System.Collections/4.0.10": { + "type": "package", + "dependencies": { + "System.Runtime": "4.0.20" + }, + "compile": { + "ref/dotnet/System.Collections.dll": {} + }, + "runtime": { + "lib/DNXCore50/System.Collections.dll": {} + } + }, + "System.Collections.Concurrent/4.0.10": { + "type": "package", + "dependencies": { + "System.Collections": "4.0.10", + "System.Diagnostics.Debug": "4.0.10", + "System.Diagnostics.Tracing": "4.0.20", + "System.Globalization": "4.0.10", + "System.Resources.ResourceManager": "4.0.0", + "System.Runtime": "4.0.20", + "System.Runtime.Extensions": "4.0.10", + "System.Threading": "4.0.10", + "System.Threading.Tasks": "4.0.10" + }, + "compile": { + "ref/dotnet/System.Collections.Concurrent.dll": {} + }, + "runtime": { + "lib/dotnet/System.Collections.Concurrent.dll": {} + } + }, + "System.Collections.Immutable/1.1.37": { + "type": "package", + "dependencies": { + "System.Collections": "4.0.0", + "System.Diagnostics.Debug": "4.0.0", + "System.Globalization": "4.0.0", + "System.Linq": "4.0.0", + "System.Resources.ResourceManager": "4.0.0", + "System.Runtime": "4.0.0", + "System.Runtime.Extensions": "4.0.0", + "System.Threading": "4.0.0" + }, + "compile": { + "lib/dotnet/System.Collections.Immutable.dll": {} + }, + "runtime": { + "lib/dotnet/System.Collections.Immutable.dll": {} + } + }, + "System.Collections.NonGeneric/4.0.0": { + "type": "package", + "dependencies": { + "System.Diagnostics.Debug": "4.0.10", + "System.Globalization": "4.0.10", + "System.Resources.ResourceManager": "4.0.0", + "System.Runtime": "4.0.20", + "System.Runtime.Extensions": "4.0.10", + "System.Threading": "4.0.10" + }, + "compile": { + "ref/dotnet/System.Collections.NonGeneric.dll": {} + }, + "runtime": { + "lib/dotnet/System.Collections.NonGeneric.dll": {} + } + }, + "System.ComponentModel/4.0.0": { + "type": "package", + "dependencies": { + "System.Runtime": "4.0.20" + }, + "compile": { + "ref/dotnet/System.ComponentModel.dll": {} + }, + "runtime": { + "lib/dotnet/System.ComponentModel.dll": {} + } + }, + "System.ComponentModel.Annotations/4.0.10": { + "type": "package", + "dependencies": { + "System.Collections": "4.0.10", + "System.ComponentModel": "4.0.0", + "System.Globalization": "4.0.10", + "System.Linq": "4.0.0", + "System.Reflection": "4.0.10", + "System.Reflection.Extensions": "4.0.0", + "System.Resources.ResourceManager": "4.0.0", + "System.Runtime": "4.0.20", + "System.Runtime.Extensions": "4.0.10", + "System.Text.RegularExpressions": "4.0.10", + "System.Threading": "4.0.10" + }, + "compile": { + "ref/dotnet/System.ComponentModel.Annotations.dll": {} + }, + "runtime": { + "lib/dotnet/System.ComponentModel.Annotations.dll": {} + } + }, + "System.ComponentModel.EventBasedAsync/4.0.10": { + "type": "package", + "dependencies": { + "System.Resources.ResourceManager": "4.0.0", + "System.Runtime": "4.0.20", + "System.Threading": "4.0.10", + "System.Threading.Tasks": "4.0.10" + }, + "compile": { + "ref/dotnet/System.ComponentModel.EventBasedAsync.dll": {} + }, + "runtime": { + "lib/dotnet/System.ComponentModel.EventBasedAsync.dll": {} + } + }, + "System.Diagnostics.Contracts/4.0.0": { + "type": "package", + "dependencies": { + "System.Runtime": "4.0.0" + }, + "compile": { + "ref/dotnet/System.Diagnostics.Contracts.dll": {} + }, + "runtime": { + "lib/DNXCore50/System.Diagnostics.Contracts.dll": {} + } + }, + "System.Diagnostics.Debug/4.0.10": { + "type": "package", + "dependencies": { + "System.Runtime": "4.0.0" + }, + "compile": { + "ref/dotnet/System.Diagnostics.Debug.dll": {} + }, + "runtime": { + "lib/DNXCore50/System.Diagnostics.Debug.dll": {} + } + }, + "System.Diagnostics.StackTrace/4.0.0": { + "type": "package", + "dependencies": { + "System.Reflection": "4.0.0", + "System.Runtime": "4.0.0" + }, + "compile": { + "ref/dotnet/System.Diagnostics.StackTrace.dll": {} + }, + "runtime": { + "lib/DNXCore50/System.Diagnostics.StackTrace.dll": {} + } + }, + "System.Diagnostics.Tools/4.0.0": { + "type": "package", + "dependencies": { + "System.Runtime": "4.0.0" + }, + "compile": { + "ref/dotnet/System.Diagnostics.Tools.dll": {} + }, + "runtime": { + "lib/DNXCore50/System.Diagnostics.Tools.dll": {} + } + }, + "System.Diagnostics.Tracing/4.0.20": { + "type": "package", + "dependencies": { + "System.Runtime": "4.0.0" + }, + "compile": { + "ref/dotnet/System.Diagnostics.Tracing.dll": {} + }, + "runtime": { + "lib/DNXCore50/System.Diagnostics.Tracing.dll": {} + } + }, + "System.Dynamic.Runtime/4.0.10": { + "type": "package", + "dependencies": { + "System.Collections": "4.0.0", + "System.Diagnostics.Debug": "4.0.0", + "System.Globalization": "4.0.0", + "System.Linq": "4.0.0", + "System.Linq.Expressions": "4.0.10", + "System.ObjectModel": "4.0.0", + "System.Reflection": "4.0.0", + "System.Reflection.Emit": "4.0.0", + "System.Reflection.Emit.ILGeneration": "4.0.0", + "System.Reflection.Emit.Lightweight": "4.0.0", + "System.Reflection.Primitives": "4.0.0", + "System.Reflection.TypeExtensions": "4.0.0", + "System.Resources.ResourceManager": "4.0.0", + "System.Runtime": "4.0.20", + "System.Runtime.Extensions": "4.0.0", + "System.Threading": "4.0.0" + }, + "compile": { + "ref/dotnet/System.Dynamic.Runtime.dll": {} + }, + "runtime": { + "lib/DNXCore50/System.Dynamic.Runtime.dll": {} + } + }, + "System.Globalization/4.0.10": { + "type": "package", + "dependencies": { + "System.Runtime": "4.0.0" + }, + "compile": { + "ref/dotnet/System.Globalization.dll": {} + }, + "runtime": { + "lib/DNXCore50/System.Globalization.dll": {} + } + }, + "System.Globalization.Calendars/4.0.0": { + "type": "package", + "dependencies": { + "System.Globalization": "4.0.0", + "System.Runtime": "4.0.0" + }, + "compile": { + "ref/dotnet/System.Globalization.Calendars.dll": {} + }, + "runtime": { + "lib/DNXCore50/System.Globalization.Calendars.dll": {} + } + }, + "System.Globalization.Extensions/4.0.0": { + "type": "package", + "dependencies": { + "System.Globalization": "4.0.10", + "System.Resources.ResourceManager": "4.0.0", + "System.Runtime": "4.0.20", + "System.Runtime.Extensions": "4.0.10", + "System.Runtime.InteropServices": "4.0.20" + }, + "compile": { + "ref/dotnet/System.Globalization.Extensions.dll": {} + }, + "runtime": { + "lib/dotnet/System.Globalization.Extensions.dll": {} + } + }, + "System.IO/4.0.10": { + "type": "package", + "dependencies": { + "System.Runtime": "4.0.20", + "System.Text.Encoding": "4.0.0", + "System.Threading.Tasks": "4.0.0" + }, + "compile": { + "ref/dotnet/System.IO.dll": {} + }, + "runtime": { + "lib/DNXCore50/System.IO.dll": {} + } + }, + "System.IO.Compression/4.0.0": { + "type": "package", + "dependencies": { + "System.Collections": "4.0.0", + "System.IO": "4.0.0", + "System.IO.Compression.clrcompression-x64": "4.0.0", + "System.Resources.ResourceManager": "4.0.0", + "System.Runtime": "4.0.0", + "System.Runtime.Extensions": "4.0.0", + "System.Runtime.InteropServices": "4.0.0", + "System.Text.Encoding": "4.0.0", + "System.Threading": "4.0.0", + "System.Threading.Tasks": "4.0.0" + }, + "compile": { + "ref/dotnet/System.IO.Compression.dll": {} + }, + "runtime": { + "lib/dotnet/System.IO.Compression.dll": {} + } + }, + "System.IO.Compression.clrcompression-x64/4.0.0": { + "type": "package", + "native": { + "runtimes/win7-x64/native/clrcompression.dll": {} + } + }, + "System.IO.Compression.ZipFile/4.0.0": { + "type": "package", + "dependencies": { + "System.IO": "4.0.10", + "System.IO.Compression": "4.0.0", + "System.IO.FileSystem": "4.0.0", + "System.IO.FileSystem.Primitives": "4.0.0", + "System.Resources.ResourceManager": "4.0.0", + "System.Runtime": "4.0.20", + "System.Runtime.Extensions": "4.0.10", + "System.Text.Encoding": "4.0.10" + }, + "compile": { + "ref/dotnet/System.IO.Compression.ZipFile.dll": {} + }, + "runtime": { + "lib/dotnet/System.IO.Compression.ZipFile.dll": {} + } + }, + "System.IO.FileSystem/4.0.0": { + "type": "package", + "dependencies": { + "System.Collections": "4.0.10", + "System.IO": "4.0.10", + "System.IO.FileSystem.Primitives": "4.0.0", + "System.Resources.ResourceManager": "4.0.0", + "System.Runtime": "4.0.20", + "System.Runtime.Extensions": "4.0.10", + "System.Runtime.Handles": "4.0.0", + "System.Runtime.InteropServices": "4.0.20", + "System.Text.Encoding": "4.0.10", + "System.Text.Encoding.Extensions": "4.0.10", + "System.Threading": "4.0.10", + "System.Threading.Overlapped": "4.0.0", + "System.Threading.Tasks": "4.0.10" + }, + "compile": { + "ref/dotnet/System.IO.FileSystem.dll": {} + }, + "runtime": { + "lib/DNXCore50/System.IO.FileSystem.dll": {} + } + }, + "System.IO.FileSystem.Primitives/4.0.0": { + "type": "package", + "dependencies": { + "System.Runtime": "4.0.20" + }, + "compile": { + "ref/dotnet/System.IO.FileSystem.Primitives.dll": {} + }, + "runtime": { + "lib/dotnet/System.IO.FileSystem.Primitives.dll": {} + } + }, + "System.IO.UnmanagedMemoryStream/4.0.0": { + "type": "package", + "dependencies": { + "System.IO": "4.0.10", + "System.IO.FileSystem.Primitives": "4.0.0", + "System.Resources.ResourceManager": "4.0.0", + "System.Runtime": "4.0.20", + "System.Runtime.InteropServices": "4.0.20", + "System.Threading": "4.0.10", + "System.Threading.Tasks": "4.0.10" + }, + "compile": { + "ref/dotnet/System.IO.UnmanagedMemoryStream.dll": {} + }, + "runtime": { + "lib/dotnet/System.IO.UnmanagedMemoryStream.dll": {} + } + }, + "System.Linq/4.0.0": { + "type": "package", + "dependencies": { + "System.Collections": "4.0.10", + "System.Diagnostics.Debug": "4.0.10", + "System.Resources.ResourceManager": "4.0.0", + "System.Runtime": "4.0.20", + "System.Runtime.Extensions": "4.0.10" + }, + "compile": { + "ref/dotnet/System.Linq.dll": {} + }, + "runtime": { + "lib/dotnet/System.Linq.dll": {} + } + }, + "System.Linq.Expressions/4.0.10": { + "type": "package", + "dependencies": { + "System.Collections": "4.0.0", + "System.Diagnostics.Debug": "4.0.0", + "System.Globalization": "4.0.0", + "System.IO": "4.0.0", + "System.Linq": "4.0.0", + "System.ObjectModel": "4.0.0", + "System.Reflection": "4.0.0", + "System.Reflection.Emit": "4.0.0", + "System.Reflection.Emit.ILGeneration": "4.0.0", + "System.Reflection.Emit.Lightweight": "4.0.0", + "System.Reflection.Extensions": "4.0.0", + "System.Reflection.Primitives": "4.0.0", + "System.Reflection.TypeExtensions": "4.0.0", + "System.Resources.ResourceManager": "4.0.0", + "System.Runtime": "4.0.20", + "System.Runtime.Extensions": "4.0.0", + "System.Threading": "4.0.0" + }, + "compile": { + "ref/dotnet/System.Linq.Expressions.dll": {} + }, + "runtime": { + "lib/DNXCore50/System.Linq.Expressions.dll": {} + } + }, + "System.Linq.Parallel/4.0.0": { + "type": "package", + "dependencies": { + "System.Collections": "4.0.10", + "System.Collections.Concurrent": "4.0.10", + "System.Diagnostics.Debug": "4.0.10", + "System.Diagnostics.Tracing": "4.0.20", + "System.Linq": "4.0.0", + "System.Resources.ResourceManager": "4.0.0", + "System.Runtime": "4.0.20", + "System.Runtime.Extensions": "4.0.10", + "System.Threading": "4.0.10", + "System.Threading.Tasks": "4.0.10" + }, + "compile": { + "ref/dotnet/System.Linq.Parallel.dll": {} + }, + "runtime": { + "lib/dotnet/System.Linq.Parallel.dll": {} + } + }, + "System.Linq.Queryable/4.0.0": { + "type": "package", + "dependencies": { + "System.Collections": "4.0.10", + "System.Linq": "4.0.0", + "System.Linq.Expressions": "4.0.10", + "System.Reflection": "4.0.10", + "System.Reflection.Extensions": "4.0.0", + "System.Resources.ResourceManager": "4.0.0", + "System.Runtime": "4.0.20" + }, + "compile": { + "ref/dotnet/System.Linq.Queryable.dll": {} + }, + "runtime": { + "lib/dotnet/System.Linq.Queryable.dll": {} + } + }, + "System.Net.Http/4.0.0": { + "type": "package", + "dependencies": { + "Microsoft.Win32.Primitives": "4.0.0", + "System.Collections": "4.0.10", + "System.Diagnostics.Debug": "4.0.10", + "System.Globalization": "4.0.10", + "System.IO": "4.0.10", + "System.IO.Compression": "4.0.0", + "System.Net.Primitives": "4.0.10", + "System.Resources.ResourceManager": "4.0.0", + "System.Runtime": "4.0.20", + "System.Runtime.Extensions": "4.0.10", + "System.Runtime.Handles": "4.0.0", + "System.Runtime.InteropServices": "4.0.20", + "System.Text.Encoding": "4.0.10", + "System.Threading": "4.0.10", + "System.Threading.Tasks": "4.0.10" + }, + "compile": { + "ref/dotnet/System.Net.Http.dll": {} + }, + "runtime": { + "lib/DNXCore50/System.Net.Http.dll": {} + } + }, + "System.Net.NetworkInformation/4.0.10-beta-23123": { + "type": "package", + "dependencies": { + "System.Private.Networking": "4.0.0" + }, + "compile": { + "ref/dotnet/System.Net.NetworkInformation.dll": {} + }, + "runtime": { + "lib/DNXCore50/System.Net.NetworkInformation.dll": {} + } + }, + "System.Net.Primitives/4.0.10": { + "type": "package", + "dependencies": { + "System.Private.Networking": "4.0.0" + }, + "compile": { + "ref/dotnet/System.Net.Primitives.dll": {} + }, + "runtime": { + "lib/DNXCore50/System.Net.Primitives.dll": {} + } + }, + "System.Numerics.Vectors/4.1.0": { + "type": "package", + "dependencies": { + "System.Globalization": "4.0.10", + "System.Resources.ResourceManager": "4.0.0", + "System.Runtime": "4.0.20", + "System.Runtime.Extensions": "4.0.10" + }, + "compile": { + "ref/dotnet/System.Numerics.Vectors.dll": {} + }, + "runtime": { + "lib/dotnet/System.Numerics.Vectors.dll": {} + } + }, + "System.ObjectModel/4.0.10": { + "type": "package", + "dependencies": { + "System.Collections": "4.0.10", + "System.Diagnostics.Debug": "4.0.10", + "System.Resources.ResourceManager": "4.0.0", + "System.Runtime": "4.0.20", + "System.Threading": "4.0.10" + }, + "compile": { + "ref/dotnet/System.ObjectModel.dll": {} + }, + "runtime": { + "lib/dotnet/System.ObjectModel.dll": {} + } + }, + "System.Private.Networking/4.0.0": { + "type": "package", + "dependencies": { + "Microsoft.Win32.Primitives": "4.0.0", + "System.Collections": "4.0.10", + "System.Collections.Concurrent": "4.0.0", + "System.Collections.NonGeneric": "4.0.0", + "System.ComponentModel.EventBasedAsync": "4.0.10", + "System.Diagnostics.Debug": "4.0.10", + "System.Diagnostics.Tracing": "4.0.20", + "System.Globalization": "4.0.10", + "System.IO": "4.0.10", + "System.IO.FileSystem": "4.0.0", + "System.IO.FileSystem.Primitives": "4.0.0", + "System.Resources.ResourceManager": "4.0.0", + "System.Runtime": "4.0.20", + "System.Runtime.Extensions": "4.0.10", + "System.Runtime.Handles": "4.0.0", + "System.Runtime.InteropServices": "4.0.20", + "System.Threading": "4.0.10", + "System.Threading.Overlapped": "4.0.0", + "System.Threading.Tasks": "4.0.10" + }, + "compile": { + "ref/dnxcore50/_._": {} + }, + "runtime": { + "lib/DNXCore50/System.Private.Networking.dll": {} + } + }, + "System.Private.Uri/4.0.0": { + "type": "package", + "compile": { + "ref/dnxcore50/_._": {} + }, + "runtime": { + "lib/DNXCore50/System.Private.Uri.dll": {} + } + }, + "System.Reflection/4.0.10": { + "type": "package", + "dependencies": { + "System.IO": "4.0.0", + "System.Reflection.Primitives": "4.0.0", + "System.Runtime": "4.0.20" + }, + "compile": { + "ref/dotnet/System.Reflection.dll": {} + }, + "runtime": { + "lib/DNXCore50/System.Reflection.dll": {} + } + }, + "System.Reflection.DispatchProxy/4.0.0": { + "type": "package", + "dependencies": { + "System.Collections": "4.0.10", + "System.Linq": "4.0.0", + "System.Reflection": "4.0.10", + "System.Reflection.Emit": "4.0.0", + "System.Reflection.Emit.ILGeneration": "4.0.0", + "System.Reflection.Extensions": "4.0.0", + "System.Reflection.Primitives": "4.0.0", + "System.Resources.ResourceManager": "4.0.0", + "System.Runtime": "4.0.20", + "System.Threading": "4.0.10" + }, + "compile": { + "ref/dotnet/System.Reflection.DispatchProxy.dll": {} + }, + "runtime": { + "lib/DNXCore50/System.Reflection.DispatchProxy.dll": {} + } + }, + "System.Reflection.Emit/4.0.0": { + "type": "package", + "dependencies": { + "System.IO": "4.0.0", + "System.Reflection": "4.0.0", + "System.Reflection.Emit.ILGeneration": "4.0.0", + "System.Reflection.Primitives": "4.0.0", + "System.Runtime": "4.0.0" + }, + "compile": { + "ref/dotnet/System.Reflection.Emit.dll": {} + }, + "runtime": { + "lib/DNXCore50/System.Reflection.Emit.dll": {} + } + }, + "System.Reflection.Emit.ILGeneration/4.0.0": { + "type": "package", + "dependencies": { + "System.Reflection": "4.0.0", + "System.Reflection.Primitives": "4.0.0", + "System.Runtime": "4.0.0" + }, + "compile": { + "ref/dotnet/System.Reflection.Emit.ILGeneration.dll": {} + }, + "runtime": { + "lib/DNXCore50/System.Reflection.Emit.ILGeneration.dll": {} + } + }, + "System.Reflection.Emit.Lightweight/4.0.0": { + "type": "package", + "dependencies": { + "System.Reflection": "4.0.0", + "System.Reflection.Emit.ILGeneration": "4.0.0", + "System.Reflection.Primitives": "4.0.0", + "System.Runtime": "4.0.0" + }, + "compile": { + "ref/dotnet/System.Reflection.Emit.Lightweight.dll": {} + }, + "runtime": { + "lib/DNXCore50/System.Reflection.Emit.Lightweight.dll": {} + } + }, + "System.Reflection.Extensions/4.0.0": { + "type": "package", + "dependencies": { + "System.Reflection": "4.0.0", + "System.Runtime": "4.0.0" + }, + "compile": { + "ref/dotnet/System.Reflection.Extensions.dll": {} + }, + "runtime": { + "lib/DNXCore50/System.Reflection.Extensions.dll": {} + } + }, + "System.Reflection.Metadata/1.0.22": { + "type": "package", + "dependencies": { + "System.Collections": "4.0.0", + "System.Collections.Immutable": "1.1.37", + "System.Diagnostics.Debug": "4.0.0", + "System.IO": "4.0.0", + "System.Reflection": "4.0.0", + "System.Reflection.Extensions": "4.0.0", + "System.Reflection.Primitives": "4.0.0", + "System.Resources.ResourceManager": "4.0.0", + "System.Runtime": "4.0.0", + "System.Runtime.Extensions": "4.0.0", + "System.Runtime.InteropServices": "4.0.0", + "System.Text.Encoding": "4.0.0", + "System.Text.Encoding.Extensions": "4.0.0", + "System.Threading": "4.0.0" + }, + "compile": { + "lib/dotnet/System.Reflection.Metadata.dll": {} + }, + "runtime": { + "lib/dotnet/System.Reflection.Metadata.dll": {} + } + }, + "System.Reflection.Primitives/4.0.0": { + "type": "package", + "dependencies": { + "System.Runtime": "4.0.0" + }, + "compile": { + "ref/dotnet/System.Reflection.Primitives.dll": {} + }, + "runtime": { + "lib/DNXCore50/System.Reflection.Primitives.dll": {} + } + }, + "System.Reflection.TypeExtensions/4.0.0": { + "type": "package", + "dependencies": { + "System.Reflection": "4.0.0", + "System.Runtime": "4.0.0" + }, + "compile": { + "ref/dotnet/System.Reflection.TypeExtensions.dll": {} + }, + "runtime": { + "lib/DNXCore50/System.Reflection.TypeExtensions.dll": {} + } + }, + "System.Resources.ResourceManager/4.0.0": { + "type": "package", + "dependencies": { + "System.Globalization": "4.0.0", + "System.Reflection": "4.0.0", + "System.Runtime": "4.0.0" + }, + "compile": { + "ref/dotnet/System.Resources.ResourceManager.dll": {} + }, + "runtime": { + "lib/DNXCore50/System.Resources.ResourceManager.dll": {} + } + }, + "System.Runtime/4.0.20": { + "type": "package", + "dependencies": { + "System.Private.Uri": "4.0.0" + }, + "compile": { + "ref/dotnet/System.Runtime.dll": {} + }, + "runtime": { + "lib/DNXCore50/System.Runtime.dll": {} + } + }, + "System.Runtime.Extensions/4.0.10": { + "type": "package", + "dependencies": { + "System.Runtime": "4.0.20" + }, + "compile": { + "ref/dotnet/System.Runtime.Extensions.dll": {} + }, + "runtime": { + "lib/DNXCore50/System.Runtime.Extensions.dll": {} + } + }, + "System.Runtime.Handles/4.0.0": { + "type": "package", + "dependencies": { + "System.Runtime": "4.0.0" + }, + "compile": { + "ref/dotnet/System.Runtime.Handles.dll": {} + }, + "runtime": { + "lib/DNXCore50/System.Runtime.Handles.dll": {} + } + }, + "System.Runtime.InteropServices/4.0.20": { + "type": "package", + "dependencies": { + "System.Reflection": "4.0.0", + "System.Reflection.Primitives": "4.0.0", + "System.Runtime": "4.0.0", + "System.Runtime.Handles": "4.0.0" + }, + "compile": { + "ref/dotnet/System.Runtime.InteropServices.dll": {} + }, + "runtime": { + "lib/DNXCore50/System.Runtime.InteropServices.dll": {} + } + }, + "System.Runtime.Numerics/4.0.0": { + "type": "package", + "dependencies": { + "System.Globalization": "4.0.10", + "System.Resources.ResourceManager": "4.0.0", + "System.Runtime": "4.0.20", + "System.Runtime.Extensions": "4.0.10" + }, + "compile": { + "ref/dotnet/System.Runtime.Numerics.dll": {} + }, + "runtime": { + "lib/dotnet/System.Runtime.Numerics.dll": {} + } + }, + "System.Security.Claims/4.0.0": { + "type": "package", + "dependencies": { + "System.Collections": "4.0.0", + "System.Diagnostics.Debug": "4.0.0", + "System.Globalization": "4.0.0", + "System.IO": "4.0.0", + "System.Resources.ResourceManager": "4.0.0", + "System.Runtime": "4.0.20", + "System.Runtime.Extensions": "4.0.0", + "System.Security.Principal": "4.0.0" + }, + "compile": { + "ref/dotnet/System.Security.Claims.dll": {} + }, + "runtime": { + "lib/dotnet/System.Security.Claims.dll": {} + } + }, + "System.Security.Principal/4.0.0": { + "type": "package", + "dependencies": { + "System.Runtime": "4.0.0" + }, + "compile": { + "ref/dotnet/System.Security.Principal.dll": {} + }, + "runtime": { + "lib/dotnet/System.Security.Principal.dll": {} + } + }, + "System.Text.Encoding/4.0.10": { + "type": "package", + "dependencies": { + "System.Runtime": "4.0.0" + }, + "compile": { + "ref/dotnet/System.Text.Encoding.dll": {} + }, + "runtime": { + "lib/DNXCore50/System.Text.Encoding.dll": {} + } + }, + "System.Text.Encoding.Extensions/4.0.10": { + "type": "package", + "dependencies": { + "System.Runtime": "4.0.0", + "System.Text.Encoding": "4.0.10" + }, + "compile": { + "ref/dotnet/System.Text.Encoding.Extensions.dll": {} + }, + "runtime": { + "lib/DNXCore50/System.Text.Encoding.Extensions.dll": {} + } + }, + "System.Text.RegularExpressions/4.0.10": { + "type": "package", + "dependencies": { + "System.Collections": "4.0.10", + "System.Globalization": "4.0.10", + "System.Resources.ResourceManager": "4.0.0", + "System.Runtime": "4.0.20", + "System.Runtime.Extensions": "4.0.10", + "System.Threading": "4.0.10" + }, + "compile": { + "ref/dotnet/System.Text.RegularExpressions.dll": {} + }, + "runtime": { + "lib/dotnet/System.Text.RegularExpressions.dll": {} + } + }, + "System.Threading/4.0.10": { + "type": "package", + "dependencies": { + "System.Runtime": "4.0.0", + "System.Threading.Tasks": "4.0.0" + }, + "compile": { + "ref/dotnet/System.Threading.dll": {} + }, + "runtime": { + "lib/DNXCore50/System.Threading.dll": {} + } + }, + "System.Threading.Overlapped/4.0.0": { + "type": "package", + "dependencies": { + "System.Runtime": "4.0.0", + "System.Runtime.Handles": "4.0.0" + }, + "compile": { + "ref/dotnet/System.Threading.Overlapped.dll": {} + }, + "runtime": { + "lib/DNXCore50/System.Threading.Overlapped.dll": {} + } + }, + "System.Threading.Tasks/4.0.10": { + "type": "package", + "dependencies": { + "System.Runtime": "4.0.0" + }, + "compile": { + "ref/dotnet/System.Threading.Tasks.dll": {} + }, + "runtime": { + "lib/DNXCore50/System.Threading.Tasks.dll": {} + } + }, + "System.Threading.Tasks.Dataflow/4.5.25": { + "type": "package", + "dependencies": { + "System.Collections": "4.0.0", + "System.Collections.Concurrent": "4.0.0", + "System.Diagnostics.Debug": "4.0.0", + "System.Diagnostics.Tracing": "4.0.0", + "System.Dynamic.Runtime": "4.0.0", + "System.Linq": "4.0.0", + "System.Resources.ResourceManager": "4.0.0", + "System.Runtime": "4.0.0", + "System.Runtime.Extensions": "4.0.0", + "System.Threading": "4.0.0", + "System.Threading.Tasks": "4.0.0" + }, + "compile": { + "lib/dotnet/System.Threading.Tasks.Dataflow.dll": {} + }, + "runtime": { + "lib/dotnet/System.Threading.Tasks.Dataflow.dll": {} + } + }, + "System.Threading.Tasks.Parallel/4.0.0": { + "type": "package", + "dependencies": { + "System.Collections.Concurrent": "4.0.10", + "System.Diagnostics.Debug": "4.0.10", + "System.Diagnostics.Tracing": "4.0.20", + "System.Resources.ResourceManager": "4.0.0", + "System.Runtime": "4.0.20", + "System.Runtime.Extensions": "4.0.10", + "System.Threading": "4.0.10", + "System.Threading.Tasks": "4.0.10" + }, + "compile": { + "ref/dotnet/System.Threading.Tasks.Parallel.dll": {} + }, + "runtime": { + "lib/dotnet/System.Threading.Tasks.Parallel.dll": {} + } + }, + "System.Threading.Timer/4.0.0": { + "type": "package", + "dependencies": { + "System.Runtime": "4.0.0" + }, + "compile": { + "ref/dotnet/System.Threading.Timer.dll": {} + }, + "runtime": { + "lib/DNXCore50/System.Threading.Timer.dll": {} + } + }, + "System.Xml.ReaderWriter/4.0.10": { + "type": "package", + "dependencies": { + "System.Collections": "4.0.10", + "System.Diagnostics.Debug": "4.0.10", + "System.Globalization": "4.0.10", + "System.IO": "4.0.10", + "System.IO.FileSystem": "4.0.0", + "System.IO.FileSystem.Primitives": "4.0.0", + "System.Resources.ResourceManager": "4.0.0", + "System.Runtime": "4.0.20", + "System.Runtime.Extensions": "4.0.10", + "System.Runtime.InteropServices": "4.0.20", + "System.Text.Encoding": "4.0.10", + "System.Text.Encoding.Extensions": "4.0.10", + "System.Text.RegularExpressions": "4.0.10", + "System.Threading.Tasks": "4.0.10" + }, + "compile": { + "ref/dotnet/System.Xml.ReaderWriter.dll": {} + }, + "runtime": { + "lib/dotnet/System.Xml.ReaderWriter.dll": {} + } + }, + "System.Xml.XDocument/4.0.10": { + "type": "package", + "dependencies": { + "System.Collections": "4.0.10", + "System.Diagnostics.Debug": "4.0.10", + "System.Globalization": "4.0.10", + "System.IO": "4.0.10", + "System.Reflection": "4.0.10", + "System.Resources.ResourceManager": "4.0.0", + "System.Runtime": "4.0.20", + "System.Runtime.Extensions": "4.0.10", + "System.Text.Encoding": "4.0.10", + "System.Threading": "4.0.10", + "System.Xml.ReaderWriter": "4.0.10" + }, + "compile": { + "ref/dotnet/System.Xml.XDocument.dll": {} + }, + "runtime": { + "lib/dotnet/System.Xml.XDocument.dll": {} + } + } + }, + "DNXCore,Version=v5.0/win7-x86": { + "Microsoft.CSharp/4.0.0": { + "type": "package", + "dependencies": { + "System.Collections": "4.0.10", + "System.Diagnostics.Debug": "4.0.10", + "System.Dynamic.Runtime": "4.0.0", + "System.Globalization": "4.0.10", + "System.Linq": "4.0.0", + "System.Linq.Expressions": "4.0.0", + "System.ObjectModel": "4.0.10", + "System.Reflection": "4.0.10", + "System.Reflection.Extensions": "4.0.0", + "System.Reflection.Primitives": "4.0.0", + "System.Reflection.TypeExtensions": "4.0.0", + "System.Resources.ResourceManager": "4.0.0", + "System.Runtime": "4.0.20", + "System.Runtime.Extensions": "4.0.10", + "System.Runtime.InteropServices": "4.0.20", + "System.Threading": "4.0.10" + }, + "compile": { + "ref/dotnet/Microsoft.CSharp.dll": {} + }, + "runtime": { + "lib/dotnet/Microsoft.CSharp.dll": {} + } + }, + "Microsoft.NETCore/5.0.0": { + "type": "package", + "dependencies": { + "Microsoft.CSharp": "4.0.0", + "Microsoft.NETCore.Targets": "1.0.0", + "Microsoft.VisualBasic": "10.0.0", + "System.AppContext": "4.0.0", + "System.Collections": "4.0.10", + "System.Collections.Concurrent": "4.0.10", + "System.Collections.Immutable": "1.1.37", + "System.ComponentModel": "4.0.0", + "System.ComponentModel.Annotations": "4.0.10", + "System.Diagnostics.Debug": "4.0.10", + "System.Diagnostics.Tools": "4.0.0", + "System.Diagnostics.Tracing": "4.0.20", + "System.Dynamic.Runtime": "4.0.10", + "System.Globalization": "4.0.10", + "System.Globalization.Calendars": "4.0.0", + "System.Globalization.Extensions": "4.0.0", + "System.IO": "4.0.10", + "System.IO.Compression": "4.0.0", + "System.IO.Compression.ZipFile": "4.0.0", + "System.IO.FileSystem": "4.0.0", + "System.IO.FileSystem.Primitives": "4.0.0", + "System.IO.UnmanagedMemoryStream": "4.0.0", + "System.Linq": "4.0.0", + "System.Linq.Expressions": "4.0.10", + "System.Linq.Parallel": "4.0.0", + "System.Linq.Queryable": "4.0.0", + "System.Net.Http": "4.0.0", + "System.Net.NetworkInformation": "4.0.0", + "System.Net.Primitives": "4.0.10", + "System.Numerics.Vectors": "4.1.0", + "System.ObjectModel": "4.0.10", + "System.Reflection": "4.0.10", + "System.Reflection.DispatchProxy": "4.0.0", + "System.Reflection.Extensions": "4.0.0", + "System.Reflection.Metadata": "1.0.22", + "System.Reflection.Primitives": "4.0.0", + "System.Reflection.TypeExtensions": "4.0.0", + "System.Resources.ResourceManager": "4.0.0", + "System.Runtime": "4.0.20", + "System.Runtime.Extensions": "4.0.10", + "System.Runtime.Handles": "4.0.0", + "System.Runtime.InteropServices": "4.0.20", + "System.Runtime.Numerics": "4.0.0", + "System.Security.Claims": "4.0.0", + "System.Security.Principal": "4.0.0", + "System.Text.Encoding": "4.0.10", + "System.Text.Encoding.Extensions": "4.0.10", + "System.Text.RegularExpressions": "4.0.10", + "System.Threading": "4.0.10", + "System.Threading.Tasks": "4.0.10", + "System.Threading.Tasks.Dataflow": "4.5.25", + "System.Threading.Tasks.Parallel": "4.0.0", + "System.Threading.Timer": "4.0.0", + "System.Xml.ReaderWriter": "4.0.10", + "System.Xml.XDocument": "4.0.10" + } + }, + "Microsoft.NETCore.Platforms/1.0.0": { + "type": "package" + }, + "Microsoft.NETCore.Portable.Compatibility/1.0.0": { + "type": "package", + "dependencies": { + "Microsoft.NETCore.Runtime": "1.0.0" + }, + "compile": { + "ref/dotnet/System.ComponentModel.DataAnnotations.dll": {}, + "ref/dotnet/System.Core.dll": {}, + "ref/dotnet/System.Net.dll": {}, + "ref/dotnet/System.Numerics.dll": {}, + "ref/dotnet/System.Runtime.Serialization.dll": {}, + "ref/dotnet/System.ServiceModel.Web.dll": {}, + "ref/dotnet/System.ServiceModel.dll": {}, + "ref/dotnet/System.Windows.dll": {}, + "ref/dotnet/System.Xml.Linq.dll": {}, + "ref/dotnet/System.Xml.Serialization.dll": {}, + "ref/dotnet/System.Xml.dll": {}, + "ref/dotnet/System.dll": {}, + "ref/dotnet/mscorlib.dll": {} + }, + "runtime": { + "lib/dnxcore50/System.ComponentModel.DataAnnotations.dll": {}, + "lib/dnxcore50/System.Core.dll": {}, + "lib/dnxcore50/System.Net.dll": {}, + "lib/dnxcore50/System.Numerics.dll": {}, + "lib/dnxcore50/System.Runtime.Serialization.dll": {}, + "lib/dnxcore50/System.ServiceModel.Web.dll": {}, + "lib/dnxcore50/System.ServiceModel.dll": {}, + "lib/dnxcore50/System.Windows.dll": {}, + "lib/dnxcore50/System.Xml.Linq.dll": {}, + "lib/dnxcore50/System.Xml.Serialization.dll": {}, + "lib/dnxcore50/System.Xml.dll": {}, + "lib/dnxcore50/System.dll": {} + } + }, + "Microsoft.NETCore.Runtime/1.0.0": { + "type": "package", + "dependencies": { + "Microsoft.NETCore.Runtime.CoreCLR-x86": "1.0.0", + "Microsoft.NETCore.Windows.ApiSets-x86": "1.0.0" + } + }, + "Microsoft.NETCore.Runtime.CoreCLR-x86/1.0.0": { + "type": "package", + "dependencies": { + "System.Collections": "[4.0.10]", + "System.Diagnostics.Contracts": "[4.0.0]", + "System.Diagnostics.Debug": "[4.0.10]", + "System.Diagnostics.StackTrace": "[4.0.0]", + "System.Diagnostics.Tools": "[4.0.0]", + "System.Diagnostics.Tracing": "[4.0.20]", + "System.Globalization": "[4.0.10]", + "System.Globalization.Calendars": "[4.0.0]", + "System.IO": "[4.0.10]", + "System.ObjectModel": "[4.0.10]", + "System.Private.Uri": "[4.0.0]", + "System.Reflection": "[4.0.10]", + "System.Reflection.Extensions": "[4.0.0]", + "System.Reflection.Primitives": "[4.0.0]", + "System.Resources.ResourceManager": "[4.0.0]", + "System.Runtime": "[4.0.20]", + "System.Runtime.Extensions": "[4.0.10]", + "System.Runtime.Handles": "[4.0.0]", + "System.Runtime.InteropServices": "[4.0.20]", + "System.Text.Encoding": "[4.0.10]", + "System.Text.Encoding.Extensions": "[4.0.10]", + "System.Threading": "[4.0.10]", + "System.Threading.Tasks": "[4.0.10]", + "System.Threading.Timer": "[4.0.0]" + }, + "compile": { + "ref/dotnet/_._": {} + }, + "runtime": { + "runtimes/win7-x86/lib/dotnet/mscorlib.ni.dll": {} + }, + "native": { + "runtimes/win7-x86/native/clretwrc.dll": {}, + "runtimes/win7-x86/native/coreclr.dll": {}, + "runtimes/win7-x86/native/dbgshim.dll": {}, + "runtimes/win7-x86/native/mscordaccore.dll": {}, + "runtimes/win7-x86/native/mscordbi.dll": {}, + "runtimes/win7-x86/native/mscorrc.debug.dll": {}, + "runtimes/win7-x86/native/mscorrc.dll": {} + } + }, + "Microsoft.NETCore.Targets/1.0.0": { + "type": "package", + "dependencies": { + "Microsoft.NETCore.Platforms": "1.0.0", + "Microsoft.NETCore.Targets.DNXCore": "4.9.0" + } + }, + "Microsoft.NETCore.Targets.DNXCore/4.9.0": { + "type": "package" + }, + "Microsoft.NETCore.Windows.ApiSets-x86/1.0.0": { + "type": "package", + "native": { + "runtimes/win7-x86/native/API-MS-Win-Base-Util-L1-1-0.dll": {}, + "runtimes/win7-x86/native/API-MS-Win-Core-Kernel32-Private-L1-1-0.dll": {}, + "runtimes/win7-x86/native/API-MS-Win-Core-Kernel32-Private-L1-1-1.dll": {}, + "runtimes/win7-x86/native/API-MS-Win-Core-Kernel32-Private-L1-1-2.dll": {}, + "runtimes/win7-x86/native/API-MS-Win-Core-PrivateProfile-L1-1-0.dll": {}, + "runtimes/win7-x86/native/API-MS-Win-Core-ProcessTopology-Obsolete-L1-1-0.dll": {}, + "runtimes/win7-x86/native/API-MS-Win-Core-String-L2-1-0.dll": {}, + "runtimes/win7-x86/native/API-MS-Win-Core-StringAnsi-L1-1-0.dll": {}, + "runtimes/win7-x86/native/API-MS-Win-EventLog-Legacy-L1-1-0.dll": {}, + "runtimes/win7-x86/native/API-MS-Win-Eventing-ClassicProvider-L1-1-0.dll": {}, + "runtimes/win7-x86/native/API-MS-Win-Eventing-Consumer-L1-1-0.dll": {}, + "runtimes/win7-x86/native/API-MS-Win-Eventing-Controller-L1-1-0.dll": {}, + "runtimes/win7-x86/native/API-MS-Win-Eventing-Legacy-L1-1-0.dll": {}, + "runtimes/win7-x86/native/API-MS-Win-Eventing-Provider-L1-1-0.dll": {}, + "runtimes/win7-x86/native/API-MS-Win-Security-LsaPolicy-L1-1-0.dll": {}, + "runtimes/win7-x86/native/API-MS-Win-devices-config-L1-1-0.dll": {}, + "runtimes/win7-x86/native/API-MS-Win-devices-config-L1-1-1.dll": {}, + "runtimes/win7-x86/native/api-ms-win-core-com-l1-1-0.dll": {}, + "runtimes/win7-x86/native/api-ms-win-core-com-private-l1-1-0.dll": {}, + "runtimes/win7-x86/native/api-ms-win-core-comm-l1-1-0.dll": {}, + "runtimes/win7-x86/native/api-ms-win-core-console-l1-1-0.dll": {}, + "runtimes/win7-x86/native/api-ms-win-core-console-l2-1-0.dll": {}, + "runtimes/win7-x86/native/api-ms-win-core-datetime-l1-1-0.dll": {}, + "runtimes/win7-x86/native/api-ms-win-core-datetime-l1-1-1.dll": {}, + "runtimes/win7-x86/native/api-ms-win-core-debug-l1-1-0.dll": {}, + "runtimes/win7-x86/native/api-ms-win-core-debug-l1-1-1.dll": {}, + "runtimes/win7-x86/native/api-ms-win-core-delayload-l1-1-0.dll": {}, + "runtimes/win7-x86/native/api-ms-win-core-errorhandling-l1-1-0.dll": {}, + "runtimes/win7-x86/native/api-ms-win-core-errorhandling-l1-1-1.dll": {}, + "runtimes/win7-x86/native/api-ms-win-core-fibers-l1-1-0.dll": {}, + "runtimes/win7-x86/native/api-ms-win-core-fibers-l1-1-1.dll": {}, + "runtimes/win7-x86/native/api-ms-win-core-file-l1-1-0.dll": {}, + "runtimes/win7-x86/native/api-ms-win-core-file-l1-2-0.dll": {}, + "runtimes/win7-x86/native/api-ms-win-core-file-l1-2-1.dll": {}, + "runtimes/win7-x86/native/api-ms-win-core-file-l2-1-0.dll": {}, + "runtimes/win7-x86/native/api-ms-win-core-file-l2-1-1.dll": {}, + "runtimes/win7-x86/native/api-ms-win-core-handle-l1-1-0.dll": {}, + "runtimes/win7-x86/native/api-ms-win-core-heap-l1-1-0.dll": {}, + "runtimes/win7-x86/native/api-ms-win-core-heap-obsolete-l1-1-0.dll": {}, + "runtimes/win7-x86/native/api-ms-win-core-interlocked-l1-1-0.dll": {}, + "runtimes/win7-x86/native/api-ms-win-core-io-l1-1-0.dll": {}, + "runtimes/win7-x86/native/api-ms-win-core-io-l1-1-1.dll": {}, + "runtimes/win7-x86/native/api-ms-win-core-kernel32-legacy-l1-1-0.dll": {}, + "runtimes/win7-x86/native/api-ms-win-core-kernel32-legacy-l1-1-1.dll": {}, + "runtimes/win7-x86/native/api-ms-win-core-kernel32-legacy-l1-1-2.dll": {}, + "runtimes/win7-x86/native/api-ms-win-core-libraryloader-l1-1-0.dll": {}, + "runtimes/win7-x86/native/api-ms-win-core-libraryloader-l1-1-1.dll": {}, + "runtimes/win7-x86/native/api-ms-win-core-localization-l1-2-0.dll": {}, + "runtimes/win7-x86/native/api-ms-win-core-localization-l1-2-1.dll": {}, + "runtimes/win7-x86/native/api-ms-win-core-localization-l2-1-0.dll": {}, + "runtimes/win7-x86/native/api-ms-win-core-localization-obsolete-l1-2-0.dll": {}, + "runtimes/win7-x86/native/api-ms-win-core-memory-l1-1-0.dll": {}, + "runtimes/win7-x86/native/api-ms-win-core-memory-l1-1-1.dll": {}, + "runtimes/win7-x86/native/api-ms-win-core-memory-l1-1-2.dll": {}, + "runtimes/win7-x86/native/api-ms-win-core-memory-l1-1-3.dll": {}, + "runtimes/win7-x86/native/api-ms-win-core-namedpipe-l1-1-0.dll": {}, + "runtimes/win7-x86/native/api-ms-win-core-namedpipe-l1-2-1.dll": {}, + "runtimes/win7-x86/native/api-ms-win-core-normalization-l1-1-0.dll": {}, + "runtimes/win7-x86/native/api-ms-win-core-privateprofile-l1-1-1.dll": {}, + "runtimes/win7-x86/native/api-ms-win-core-processenvironment-l1-1-0.dll": {}, + "runtimes/win7-x86/native/api-ms-win-core-processenvironment-l1-2-0.dll": {}, + "runtimes/win7-x86/native/api-ms-win-core-processsecurity-l1-1-0.dll": {}, + "runtimes/win7-x86/native/api-ms-win-core-processthreads-l1-1-0.dll": {}, + "runtimes/win7-x86/native/api-ms-win-core-processthreads-l1-1-1.dll": {}, + "runtimes/win7-x86/native/api-ms-win-core-processthreads-l1-1-2.dll": {}, + "runtimes/win7-x86/native/api-ms-win-core-profile-l1-1-0.dll": {}, + "runtimes/win7-x86/native/api-ms-win-core-psapi-ansi-l1-1-0.dll": {}, + "runtimes/win7-x86/native/api-ms-win-core-psapi-l1-1-0.dll": {}, + "runtimes/win7-x86/native/api-ms-win-core-psapi-obsolete-l1-1-0.dll": {}, + "runtimes/win7-x86/native/api-ms-win-core-realtime-l1-1-0.dll": {}, + "runtimes/win7-x86/native/api-ms-win-core-registry-l1-1-0.dll": {}, + "runtimes/win7-x86/native/api-ms-win-core-registry-l2-1-0.dll": {}, + "runtimes/win7-x86/native/api-ms-win-core-rtlsupport-l1-1-0.dll": {}, + "runtimes/win7-x86/native/api-ms-win-core-shlwapi-legacy-l1-1-0.dll": {}, + "runtimes/win7-x86/native/api-ms-win-core-shlwapi-obsolete-l1-1-0.dll": {}, + "runtimes/win7-x86/native/api-ms-win-core-shutdown-l1-1-0.dll": {}, + "runtimes/win7-x86/native/api-ms-win-core-shutdown-l1-1-1.dll": {}, + "runtimes/win7-x86/native/api-ms-win-core-string-l1-1-0.dll": {}, + "runtimes/win7-x86/native/api-ms-win-core-string-obsolete-l1-1-0.dll": {}, + "runtimes/win7-x86/native/api-ms-win-core-string-obsolete-l1-1-1.dll": {}, + "runtimes/win7-x86/native/api-ms-win-core-stringloader-l1-1-0.dll": {}, + "runtimes/win7-x86/native/api-ms-win-core-stringloader-l1-1-1.dll": {}, + "runtimes/win7-x86/native/api-ms-win-core-synch-l1-1-0.dll": {}, + "runtimes/win7-x86/native/api-ms-win-core-synch-l1-2-0.dll": {}, + "runtimes/win7-x86/native/api-ms-win-core-sysinfo-l1-1-0.dll": {}, + "runtimes/win7-x86/native/api-ms-win-core-sysinfo-l1-2-0.dll": {}, + "runtimes/win7-x86/native/api-ms-win-core-sysinfo-l1-2-1.dll": {}, + "runtimes/win7-x86/native/api-ms-win-core-sysinfo-l1-2-2.dll": {}, + "runtimes/win7-x86/native/api-ms-win-core-sysinfo-l1-2-3.dll": {}, + "runtimes/win7-x86/native/api-ms-win-core-threadpool-l1-2-0.dll": {}, + "runtimes/win7-x86/native/api-ms-win-core-threadpool-legacy-l1-1-0.dll": {}, + "runtimes/win7-x86/native/api-ms-win-core-threadpool-private-l1-1-0.dll": {}, + "runtimes/win7-x86/native/api-ms-win-core-timezone-l1-1-0.dll": {}, + "runtimes/win7-x86/native/api-ms-win-core-url-l1-1-0.dll": {}, + "runtimes/win7-x86/native/api-ms-win-core-util-l1-1-0.dll": {}, + "runtimes/win7-x86/native/api-ms-win-core-version-l1-1-0.dll": {}, + "runtimes/win7-x86/native/api-ms-win-core-winrt-error-l1-1-0.dll": {}, + "runtimes/win7-x86/native/api-ms-win-core-winrt-error-l1-1-1.dll": {}, + "runtimes/win7-x86/native/api-ms-win-core-winrt-l1-1-0.dll": {}, + "runtimes/win7-x86/native/api-ms-win-core-winrt-registration-l1-1-0.dll": {}, + "runtimes/win7-x86/native/api-ms-win-core-winrt-robuffer-l1-1-0.dll": {}, + "runtimes/win7-x86/native/api-ms-win-core-winrt-roparameterizediid-l1-1-0.dll": {}, + "runtimes/win7-x86/native/api-ms-win-core-winrt-string-l1-1-0.dll": {}, + "runtimes/win7-x86/native/api-ms-win-core-wow64-l1-1-0.dll": {}, + "runtimes/win7-x86/native/api-ms-win-core-xstate-l1-1-0.dll": {}, + "runtimes/win7-x86/native/api-ms-win-core-xstate-l2-1-0.dll": {}, + "runtimes/win7-x86/native/api-ms-win-ro-typeresolution-l1-1-0.dll": {}, + "runtimes/win7-x86/native/api-ms-win-security-base-l1-1-0.dll": {}, + "runtimes/win7-x86/native/api-ms-win-security-cpwl-l1-1-0.dll": {}, + "runtimes/win7-x86/native/api-ms-win-security-cryptoapi-l1-1-0.dll": {}, + "runtimes/win7-x86/native/api-ms-win-security-lsalookup-l2-1-0.dll": {}, + "runtimes/win7-x86/native/api-ms-win-security-lsalookup-l2-1-1.dll": {}, + "runtimes/win7-x86/native/api-ms-win-security-provider-l1-1-0.dll": {}, + "runtimes/win7-x86/native/api-ms-win-security-sddl-l1-1-0.dll": {}, + "runtimes/win7-x86/native/api-ms-win-service-core-l1-1-0.dll": {}, + "runtimes/win7-x86/native/api-ms-win-service-core-l1-1-1.dll": {}, + "runtimes/win7-x86/native/api-ms-win-service-management-l1-1-0.dll": {}, + "runtimes/win7-x86/native/api-ms-win-service-management-l2-1-0.dll": {}, + "runtimes/win7-x86/native/api-ms-win-service-private-l1-1-0.dll": {}, + "runtimes/win7-x86/native/api-ms-win-service-private-l1-1-1.dll": {}, + "runtimes/win7-x86/native/api-ms-win-service-winsvc-l1-1-0.dll": {}, + "runtimes/win7-x86/native/ext-ms-win-advapi32-encryptedfile-l1-1-0.dll": {} + } + }, + "Microsoft.VisualBasic/10.0.0": { + "type": "package", + "dependencies": { + "System.Collections": "4.0.10", + "System.Diagnostics.Debug": "4.0.10", + "System.Dynamic.Runtime": "4.0.10", + "System.Globalization": "4.0.10", + "System.Linq": "4.0.0", + "System.Linq.Expressions": "4.0.10", + "System.ObjectModel": "4.0.10", + "System.Reflection": "4.0.10", + "System.Reflection.Extensions": "4.0.0", + "System.Reflection.Primitives": "4.0.0", + "System.Reflection.TypeExtensions": "4.0.0", + "System.Resources.ResourceManager": "4.0.0", + "System.Runtime": "4.0.20", + "System.Runtime.Extensions": "4.0.10", + "System.Runtime.InteropServices": "4.0.20", + "System.Threading": "4.0.10" + }, + "compile": { + "ref/dotnet/Microsoft.VisualBasic.dll": {} + }, + "runtime": { + "lib/dotnet/Microsoft.VisualBasic.dll": {} + } + }, + "Microsoft.Win32.Primitives/4.0.0": { + "type": "package", + "dependencies": { + "System.Runtime": "4.0.20", + "System.Runtime.InteropServices": "4.0.20" + }, + "compile": { + "ref/dotnet/Microsoft.Win32.Primitives.dll": {} + }, + "runtime": { + "lib/dotnet/Microsoft.Win32.Primitives.dll": {} + } + }, + "System.AppContext/4.0.0": { + "type": "package", + "dependencies": { + "System.Runtime": "4.0.0" + }, + "compile": { + "ref/dotnet/System.AppContext.dll": {} + }, + "runtime": { + "lib/DNXCore50/System.AppContext.dll": {} + } + }, + "System.Collections/4.0.10": { + "type": "package", + "dependencies": { + "System.Runtime": "4.0.20" + }, + "compile": { + "ref/dotnet/System.Collections.dll": {} + }, + "runtime": { + "lib/DNXCore50/System.Collections.dll": {} + } + }, + "System.Collections.Concurrent/4.0.10": { + "type": "package", + "dependencies": { + "System.Collections": "4.0.10", + "System.Diagnostics.Debug": "4.0.10", + "System.Diagnostics.Tracing": "4.0.20", + "System.Globalization": "4.0.10", + "System.Resources.ResourceManager": "4.0.0", + "System.Runtime": "4.0.20", + "System.Runtime.Extensions": "4.0.10", + "System.Threading": "4.0.10", + "System.Threading.Tasks": "4.0.10" + }, + "compile": { + "ref/dotnet/System.Collections.Concurrent.dll": {} + }, + "runtime": { + "lib/dotnet/System.Collections.Concurrent.dll": {} + } + }, + "System.Collections.Immutable/1.1.37": { + "type": "package", + "dependencies": { + "System.Collections": "4.0.0", + "System.Diagnostics.Debug": "4.0.0", + "System.Globalization": "4.0.0", + "System.Linq": "4.0.0", + "System.Resources.ResourceManager": "4.0.0", + "System.Runtime": "4.0.0", + "System.Runtime.Extensions": "4.0.0", + "System.Threading": "4.0.0" + }, + "compile": { + "lib/dotnet/System.Collections.Immutable.dll": {} + }, + "runtime": { + "lib/dotnet/System.Collections.Immutable.dll": {} + } + }, + "System.Collections.NonGeneric/4.0.0": { + "type": "package", + "dependencies": { + "System.Diagnostics.Debug": "4.0.10", + "System.Globalization": "4.0.10", + "System.Resources.ResourceManager": "4.0.0", + "System.Runtime": "4.0.20", + "System.Runtime.Extensions": "4.0.10", + "System.Threading": "4.0.10" + }, + "compile": { + "ref/dotnet/System.Collections.NonGeneric.dll": {} + }, + "runtime": { + "lib/dotnet/System.Collections.NonGeneric.dll": {} + } + }, + "System.ComponentModel/4.0.0": { + "type": "package", + "dependencies": { + "System.Runtime": "4.0.20" + }, + "compile": { + "ref/dotnet/System.ComponentModel.dll": {} + }, + "runtime": { + "lib/dotnet/System.ComponentModel.dll": {} + } + }, + "System.ComponentModel.Annotations/4.0.10": { + "type": "package", + "dependencies": { + "System.Collections": "4.0.10", + "System.ComponentModel": "4.0.0", + "System.Globalization": "4.0.10", + "System.Linq": "4.0.0", + "System.Reflection": "4.0.10", + "System.Reflection.Extensions": "4.0.0", + "System.Resources.ResourceManager": "4.0.0", + "System.Runtime": "4.0.20", + "System.Runtime.Extensions": "4.0.10", + "System.Text.RegularExpressions": "4.0.10", + "System.Threading": "4.0.10" + }, + "compile": { + "ref/dotnet/System.ComponentModel.Annotations.dll": {} + }, + "runtime": { + "lib/dotnet/System.ComponentModel.Annotations.dll": {} + } + }, + "System.ComponentModel.EventBasedAsync/4.0.10": { + "type": "package", + "dependencies": { + "System.Resources.ResourceManager": "4.0.0", + "System.Runtime": "4.0.20", + "System.Threading": "4.0.10", + "System.Threading.Tasks": "4.0.10" + }, + "compile": { + "ref/dotnet/System.ComponentModel.EventBasedAsync.dll": {} + }, + "runtime": { + "lib/dotnet/System.ComponentModel.EventBasedAsync.dll": {} + } + }, + "System.Diagnostics.Contracts/4.0.0": { + "type": "package", + "dependencies": { + "System.Runtime": "4.0.0" + }, + "compile": { + "ref/dotnet/System.Diagnostics.Contracts.dll": {} + }, + "runtime": { + "lib/DNXCore50/System.Diagnostics.Contracts.dll": {} + } + }, + "System.Diagnostics.Debug/4.0.10": { + "type": "package", + "dependencies": { + "System.Runtime": "4.0.0" + }, + "compile": { + "ref/dotnet/System.Diagnostics.Debug.dll": {} + }, + "runtime": { + "lib/DNXCore50/System.Diagnostics.Debug.dll": {} + } + }, + "System.Diagnostics.StackTrace/4.0.0": { + "type": "package", + "dependencies": { + "System.Reflection": "4.0.0", + "System.Runtime": "4.0.0" + }, + "compile": { + "ref/dotnet/System.Diagnostics.StackTrace.dll": {} + }, + "runtime": { + "lib/DNXCore50/System.Diagnostics.StackTrace.dll": {} + } + }, + "System.Diagnostics.Tools/4.0.0": { + "type": "package", + "dependencies": { + "System.Runtime": "4.0.0" + }, + "compile": { + "ref/dotnet/System.Diagnostics.Tools.dll": {} + }, + "runtime": { + "lib/DNXCore50/System.Diagnostics.Tools.dll": {} + } + }, + "System.Diagnostics.Tracing/4.0.20": { + "type": "package", + "dependencies": { + "System.Runtime": "4.0.0" + }, + "compile": { + "ref/dotnet/System.Diagnostics.Tracing.dll": {} + }, + "runtime": { + "lib/DNXCore50/System.Diagnostics.Tracing.dll": {} + } + }, + "System.Dynamic.Runtime/4.0.10": { + "type": "package", + "dependencies": { + "System.Collections": "4.0.0", + "System.Diagnostics.Debug": "4.0.0", + "System.Globalization": "4.0.0", + "System.Linq": "4.0.0", + "System.Linq.Expressions": "4.0.10", + "System.ObjectModel": "4.0.0", + "System.Reflection": "4.0.0", + "System.Reflection.Emit": "4.0.0", + "System.Reflection.Emit.ILGeneration": "4.0.0", + "System.Reflection.Emit.Lightweight": "4.0.0", + "System.Reflection.Primitives": "4.0.0", + "System.Reflection.TypeExtensions": "4.0.0", + "System.Resources.ResourceManager": "4.0.0", + "System.Runtime": "4.0.20", + "System.Runtime.Extensions": "4.0.0", + "System.Threading": "4.0.0" + }, + "compile": { + "ref/dotnet/System.Dynamic.Runtime.dll": {} + }, + "runtime": { + "lib/DNXCore50/System.Dynamic.Runtime.dll": {} + } + }, + "System.Globalization/4.0.10": { + "type": "package", + "dependencies": { + "System.Runtime": "4.0.0" + }, + "compile": { + "ref/dotnet/System.Globalization.dll": {} + }, + "runtime": { + "lib/DNXCore50/System.Globalization.dll": {} + } + }, + "System.Globalization.Calendars/4.0.0": { + "type": "package", + "dependencies": { + "System.Globalization": "4.0.0", + "System.Runtime": "4.0.0" + }, + "compile": { + "ref/dotnet/System.Globalization.Calendars.dll": {} + }, + "runtime": { + "lib/DNXCore50/System.Globalization.Calendars.dll": {} + } + }, + "System.Globalization.Extensions/4.0.0": { + "type": "package", + "dependencies": { + "System.Globalization": "4.0.10", + "System.Resources.ResourceManager": "4.0.0", + "System.Runtime": "4.0.20", + "System.Runtime.Extensions": "4.0.10", + "System.Runtime.InteropServices": "4.0.20" + }, + "compile": { + "ref/dotnet/System.Globalization.Extensions.dll": {} + }, + "runtime": { + "lib/dotnet/System.Globalization.Extensions.dll": {} + } + }, + "System.IO/4.0.10": { + "type": "package", + "dependencies": { + "System.Runtime": "4.0.20", + "System.Text.Encoding": "4.0.0", + "System.Threading.Tasks": "4.0.0" + }, + "compile": { + "ref/dotnet/System.IO.dll": {} + }, + "runtime": { + "lib/DNXCore50/System.IO.dll": {} + } + }, + "System.IO.Compression/4.0.0": { + "type": "package", + "dependencies": { + "System.Collections": "4.0.0", + "System.IO": "4.0.0", + "System.IO.Compression.clrcompression-x86": "4.0.0", + "System.Resources.ResourceManager": "4.0.0", + "System.Runtime": "4.0.0", + "System.Runtime.Extensions": "4.0.0", + "System.Runtime.InteropServices": "4.0.0", + "System.Text.Encoding": "4.0.0", + "System.Threading": "4.0.0", + "System.Threading.Tasks": "4.0.0" + }, + "compile": { + "ref/dotnet/System.IO.Compression.dll": {} + }, + "runtime": { + "lib/dotnet/System.IO.Compression.dll": {} + } + }, + "System.IO.Compression.clrcompression-x86/4.0.0": { + "type": "package", + "native": { + "runtimes/win7-x86/native/clrcompression.dll": {} + } + }, + "System.IO.Compression.ZipFile/4.0.0": { + "type": "package", + "dependencies": { + "System.IO": "4.0.10", + "System.IO.Compression": "4.0.0", + "System.IO.FileSystem": "4.0.0", + "System.IO.FileSystem.Primitives": "4.0.0", + "System.Resources.ResourceManager": "4.0.0", + "System.Runtime": "4.0.20", + "System.Runtime.Extensions": "4.0.10", + "System.Text.Encoding": "4.0.10" + }, + "compile": { + "ref/dotnet/System.IO.Compression.ZipFile.dll": {} + }, + "runtime": { + "lib/dotnet/System.IO.Compression.ZipFile.dll": {} + } + }, + "System.IO.FileSystem/4.0.0": { + "type": "package", + "dependencies": { + "System.Collections": "4.0.10", + "System.IO": "4.0.10", + "System.IO.FileSystem.Primitives": "4.0.0", + "System.Resources.ResourceManager": "4.0.0", + "System.Runtime": "4.0.20", + "System.Runtime.Extensions": "4.0.10", + "System.Runtime.Handles": "4.0.0", + "System.Runtime.InteropServices": "4.0.20", + "System.Text.Encoding": "4.0.10", + "System.Text.Encoding.Extensions": "4.0.10", + "System.Threading": "4.0.10", + "System.Threading.Overlapped": "4.0.0", + "System.Threading.Tasks": "4.0.10" + }, + "compile": { + "ref/dotnet/System.IO.FileSystem.dll": {} + }, + "runtime": { + "lib/DNXCore50/System.IO.FileSystem.dll": {} + } + }, + "System.IO.FileSystem.Primitives/4.0.0": { + "type": "package", + "dependencies": { + "System.Runtime": "4.0.20" + }, + "compile": { + "ref/dotnet/System.IO.FileSystem.Primitives.dll": {} + }, + "runtime": { + "lib/dotnet/System.IO.FileSystem.Primitives.dll": {} + } + }, + "System.IO.UnmanagedMemoryStream/4.0.0": { + "type": "package", + "dependencies": { + "System.IO": "4.0.10", + "System.IO.FileSystem.Primitives": "4.0.0", + "System.Resources.ResourceManager": "4.0.0", + "System.Runtime": "4.0.20", + "System.Runtime.InteropServices": "4.0.20", + "System.Threading": "4.0.10", + "System.Threading.Tasks": "4.0.10" + }, + "compile": { + "ref/dotnet/System.IO.UnmanagedMemoryStream.dll": {} + }, + "runtime": { + "lib/dotnet/System.IO.UnmanagedMemoryStream.dll": {} + } + }, + "System.Linq/4.0.0": { + "type": "package", + "dependencies": { + "System.Collections": "4.0.10", + "System.Diagnostics.Debug": "4.0.10", + "System.Resources.ResourceManager": "4.0.0", + "System.Runtime": "4.0.20", + "System.Runtime.Extensions": "4.0.10" + }, + "compile": { + "ref/dotnet/System.Linq.dll": {} + }, + "runtime": { + "lib/dotnet/System.Linq.dll": {} + } + }, + "System.Linq.Expressions/4.0.10": { + "type": "package", + "dependencies": { + "System.Collections": "4.0.0", + "System.Diagnostics.Debug": "4.0.0", + "System.Globalization": "4.0.0", + "System.IO": "4.0.0", + "System.Linq": "4.0.0", + "System.ObjectModel": "4.0.0", + "System.Reflection": "4.0.0", + "System.Reflection.Emit": "4.0.0", + "System.Reflection.Emit.ILGeneration": "4.0.0", + "System.Reflection.Emit.Lightweight": "4.0.0", + "System.Reflection.Extensions": "4.0.0", + "System.Reflection.Primitives": "4.0.0", + "System.Reflection.TypeExtensions": "4.0.0", + "System.Resources.ResourceManager": "4.0.0", + "System.Runtime": "4.0.20", + "System.Runtime.Extensions": "4.0.0", + "System.Threading": "4.0.0" + }, + "compile": { + "ref/dotnet/System.Linq.Expressions.dll": {} + }, + "runtime": { + "lib/DNXCore50/System.Linq.Expressions.dll": {} + } + }, + "System.Linq.Parallel/4.0.0": { + "type": "package", + "dependencies": { + "System.Collections": "4.0.10", + "System.Collections.Concurrent": "4.0.10", + "System.Diagnostics.Debug": "4.0.10", + "System.Diagnostics.Tracing": "4.0.20", + "System.Linq": "4.0.0", + "System.Resources.ResourceManager": "4.0.0", + "System.Runtime": "4.0.20", + "System.Runtime.Extensions": "4.0.10", + "System.Threading": "4.0.10", + "System.Threading.Tasks": "4.0.10" + }, + "compile": { + "ref/dotnet/System.Linq.Parallel.dll": {} + }, + "runtime": { + "lib/dotnet/System.Linq.Parallel.dll": {} + } + }, + "System.Linq.Queryable/4.0.0": { + "type": "package", + "dependencies": { + "System.Collections": "4.0.10", + "System.Linq": "4.0.0", + "System.Linq.Expressions": "4.0.10", + "System.Reflection": "4.0.10", + "System.Reflection.Extensions": "4.0.0", + "System.Resources.ResourceManager": "4.0.0", + "System.Runtime": "4.0.20" + }, + "compile": { + "ref/dotnet/System.Linq.Queryable.dll": {} + }, + "runtime": { + "lib/dotnet/System.Linq.Queryable.dll": {} + } + }, + "System.Net.Http/4.0.0": { + "type": "package", + "dependencies": { + "Microsoft.Win32.Primitives": "4.0.0", + "System.Collections": "4.0.10", + "System.Diagnostics.Debug": "4.0.10", + "System.Globalization": "4.0.10", + "System.IO": "4.0.10", + "System.IO.Compression": "4.0.0", + "System.Net.Primitives": "4.0.10", + "System.Resources.ResourceManager": "4.0.0", + "System.Runtime": "4.0.20", + "System.Runtime.Extensions": "4.0.10", + "System.Runtime.Handles": "4.0.0", + "System.Runtime.InteropServices": "4.0.20", + "System.Text.Encoding": "4.0.10", + "System.Threading": "4.0.10", + "System.Threading.Tasks": "4.0.10" + }, + "compile": { + "ref/dotnet/System.Net.Http.dll": {} + }, + "runtime": { + "lib/DNXCore50/System.Net.Http.dll": {} + } + }, + "System.Net.NetworkInformation/4.0.10-beta-23123": { + "type": "package", + "dependencies": { + "System.Private.Networking": "4.0.0" + }, + "compile": { + "ref/dotnet/System.Net.NetworkInformation.dll": {} + }, + "runtime": { + "lib/DNXCore50/System.Net.NetworkInformation.dll": {} + } + }, + "System.Net.Primitives/4.0.10": { + "type": "package", + "dependencies": { + "System.Private.Networking": "4.0.0" + }, + "compile": { + "ref/dotnet/System.Net.Primitives.dll": {} + }, + "runtime": { + "lib/DNXCore50/System.Net.Primitives.dll": {} + } + }, + "System.Numerics.Vectors/4.1.0": { + "type": "package", + "dependencies": { + "System.Globalization": "4.0.10", + "System.Resources.ResourceManager": "4.0.0", + "System.Runtime": "4.0.20", + "System.Runtime.Extensions": "4.0.10" + }, + "compile": { + "ref/dotnet/System.Numerics.Vectors.dll": {} + }, + "runtime": { + "lib/dotnet/System.Numerics.Vectors.dll": {} + } + }, + "System.ObjectModel/4.0.10": { + "type": "package", + "dependencies": { + "System.Collections": "4.0.10", + "System.Diagnostics.Debug": "4.0.10", + "System.Resources.ResourceManager": "4.0.0", + "System.Runtime": "4.0.20", + "System.Threading": "4.0.10" + }, + "compile": { + "ref/dotnet/System.ObjectModel.dll": {} + }, + "runtime": { + "lib/dotnet/System.ObjectModel.dll": {} + } + }, + "System.Private.Networking/4.0.0": { + "type": "package", + "dependencies": { + "Microsoft.Win32.Primitives": "4.0.0", + "System.Collections": "4.0.10", + "System.Collections.Concurrent": "4.0.0", + "System.Collections.NonGeneric": "4.0.0", + "System.ComponentModel.EventBasedAsync": "4.0.10", + "System.Diagnostics.Debug": "4.0.10", + "System.Diagnostics.Tracing": "4.0.20", + "System.Globalization": "4.0.10", + "System.IO": "4.0.10", + "System.IO.FileSystem": "4.0.0", + "System.IO.FileSystem.Primitives": "4.0.0", + "System.Resources.ResourceManager": "4.0.0", + "System.Runtime": "4.0.20", + "System.Runtime.Extensions": "4.0.10", + "System.Runtime.Handles": "4.0.0", + "System.Runtime.InteropServices": "4.0.20", + "System.Threading": "4.0.10", + "System.Threading.Overlapped": "4.0.0", + "System.Threading.Tasks": "4.0.10" + }, + "compile": { + "ref/dnxcore50/_._": {} + }, + "runtime": { + "lib/DNXCore50/System.Private.Networking.dll": {} + } + }, + "System.Private.Uri/4.0.0": { + "type": "package", + "compile": { + "ref/dnxcore50/_._": {} + }, + "runtime": { + "lib/DNXCore50/System.Private.Uri.dll": {} + } + }, + "System.Reflection/4.0.10": { + "type": "package", + "dependencies": { + "System.IO": "4.0.0", + "System.Reflection.Primitives": "4.0.0", + "System.Runtime": "4.0.20" + }, + "compile": { + "ref/dotnet/System.Reflection.dll": {} + }, + "runtime": { + "lib/DNXCore50/System.Reflection.dll": {} + } + }, + "System.Reflection.DispatchProxy/4.0.0": { + "type": "package", + "dependencies": { + "System.Collections": "4.0.10", + "System.Linq": "4.0.0", + "System.Reflection": "4.0.10", + "System.Reflection.Emit": "4.0.0", + "System.Reflection.Emit.ILGeneration": "4.0.0", + "System.Reflection.Extensions": "4.0.0", + "System.Reflection.Primitives": "4.0.0", + "System.Resources.ResourceManager": "4.0.0", + "System.Runtime": "4.0.20", + "System.Threading": "4.0.10" + }, + "compile": { + "ref/dotnet/System.Reflection.DispatchProxy.dll": {} + }, + "runtime": { + "lib/DNXCore50/System.Reflection.DispatchProxy.dll": {} + } + }, + "System.Reflection.Emit/4.0.0": { + "type": "package", + "dependencies": { + "System.IO": "4.0.0", + "System.Reflection": "4.0.0", + "System.Reflection.Emit.ILGeneration": "4.0.0", + "System.Reflection.Primitives": "4.0.0", + "System.Runtime": "4.0.0" + }, + "compile": { + "ref/dotnet/System.Reflection.Emit.dll": {} + }, + "runtime": { + "lib/DNXCore50/System.Reflection.Emit.dll": {} + } + }, + "System.Reflection.Emit.ILGeneration/4.0.0": { + "type": "package", + "dependencies": { + "System.Reflection": "4.0.0", + "System.Reflection.Primitives": "4.0.0", + "System.Runtime": "4.0.0" + }, + "compile": { + "ref/dotnet/System.Reflection.Emit.ILGeneration.dll": {} + }, + "runtime": { + "lib/DNXCore50/System.Reflection.Emit.ILGeneration.dll": {} + } + }, + "System.Reflection.Emit.Lightweight/4.0.0": { + "type": "package", + "dependencies": { + "System.Reflection": "4.0.0", + "System.Reflection.Emit.ILGeneration": "4.0.0", + "System.Reflection.Primitives": "4.0.0", + "System.Runtime": "4.0.0" + }, + "compile": { + "ref/dotnet/System.Reflection.Emit.Lightweight.dll": {} + }, + "runtime": { + "lib/DNXCore50/System.Reflection.Emit.Lightweight.dll": {} + } + }, + "System.Reflection.Extensions/4.0.0": { + "type": "package", + "dependencies": { + "System.Reflection": "4.0.0", + "System.Runtime": "4.0.0" + }, + "compile": { + "ref/dotnet/System.Reflection.Extensions.dll": {} + }, + "runtime": { + "lib/DNXCore50/System.Reflection.Extensions.dll": {} + } + }, + "System.Reflection.Metadata/1.0.22": { + "type": "package", + "dependencies": { + "System.Collections": "4.0.0", + "System.Collections.Immutable": "1.1.37", + "System.Diagnostics.Debug": "4.0.0", + "System.IO": "4.0.0", + "System.Reflection": "4.0.0", + "System.Reflection.Extensions": "4.0.0", + "System.Reflection.Primitives": "4.0.0", + "System.Resources.ResourceManager": "4.0.0", + "System.Runtime": "4.0.0", + "System.Runtime.Extensions": "4.0.0", + "System.Runtime.InteropServices": "4.0.0", + "System.Text.Encoding": "4.0.0", + "System.Text.Encoding.Extensions": "4.0.0", + "System.Threading": "4.0.0" + }, + "compile": { + "lib/dotnet/System.Reflection.Metadata.dll": {} + }, + "runtime": { + "lib/dotnet/System.Reflection.Metadata.dll": {} + } + }, + "System.Reflection.Primitives/4.0.0": { + "type": "package", + "dependencies": { + "System.Runtime": "4.0.0" + }, + "compile": { + "ref/dotnet/System.Reflection.Primitives.dll": {} + }, + "runtime": { + "lib/DNXCore50/System.Reflection.Primitives.dll": {} + } + }, + "System.Reflection.TypeExtensions/4.0.0": { + "type": "package", + "dependencies": { + "System.Reflection": "4.0.0", + "System.Runtime": "4.0.0" + }, + "compile": { + "ref/dotnet/System.Reflection.TypeExtensions.dll": {} + }, + "runtime": { + "lib/DNXCore50/System.Reflection.TypeExtensions.dll": {} + } + }, + "System.Resources.ResourceManager/4.0.0": { + "type": "package", + "dependencies": { + "System.Globalization": "4.0.0", + "System.Reflection": "4.0.0", + "System.Runtime": "4.0.0" + }, + "compile": { + "ref/dotnet/System.Resources.ResourceManager.dll": {} + }, + "runtime": { + "lib/DNXCore50/System.Resources.ResourceManager.dll": {} + } + }, + "System.Runtime/4.0.20": { + "type": "package", + "dependencies": { + "System.Private.Uri": "4.0.0" + }, + "compile": { + "ref/dotnet/System.Runtime.dll": {} + }, + "runtime": { + "lib/DNXCore50/System.Runtime.dll": {} + } + }, + "System.Runtime.Extensions/4.0.10": { + "type": "package", + "dependencies": { + "System.Runtime": "4.0.20" + }, + "compile": { + "ref/dotnet/System.Runtime.Extensions.dll": {} + }, + "runtime": { + "lib/DNXCore50/System.Runtime.Extensions.dll": {} + } + }, + "System.Runtime.Handles/4.0.0": { + "type": "package", + "dependencies": { + "System.Runtime": "4.0.0" + }, + "compile": { + "ref/dotnet/System.Runtime.Handles.dll": {} + }, + "runtime": { + "lib/DNXCore50/System.Runtime.Handles.dll": {} + } + }, + "System.Runtime.InteropServices/4.0.20": { + "type": "package", + "dependencies": { + "System.Reflection": "4.0.0", + "System.Reflection.Primitives": "4.0.0", + "System.Runtime": "4.0.0", + "System.Runtime.Handles": "4.0.0" + }, + "compile": { + "ref/dotnet/System.Runtime.InteropServices.dll": {} + }, + "runtime": { + "lib/DNXCore50/System.Runtime.InteropServices.dll": {} + } + }, + "System.Runtime.Numerics/4.0.0": { + "type": "package", + "dependencies": { + "System.Globalization": "4.0.10", + "System.Resources.ResourceManager": "4.0.0", + "System.Runtime": "4.0.20", + "System.Runtime.Extensions": "4.0.10" + }, + "compile": { + "ref/dotnet/System.Runtime.Numerics.dll": {} + }, + "runtime": { + "lib/dotnet/System.Runtime.Numerics.dll": {} + } + }, + "System.Security.Claims/4.0.0": { + "type": "package", + "dependencies": { + "System.Collections": "4.0.0", + "System.Diagnostics.Debug": "4.0.0", + "System.Globalization": "4.0.0", + "System.IO": "4.0.0", + "System.Resources.ResourceManager": "4.0.0", + "System.Runtime": "4.0.20", + "System.Runtime.Extensions": "4.0.0", + "System.Security.Principal": "4.0.0" + }, + "compile": { + "ref/dotnet/System.Security.Claims.dll": {} + }, + "runtime": { + "lib/dotnet/System.Security.Claims.dll": {} + } + }, + "System.Security.Principal/4.0.0": { + "type": "package", + "dependencies": { + "System.Runtime": "4.0.0" + }, + "compile": { + "ref/dotnet/System.Security.Principal.dll": {} + }, + "runtime": { + "lib/dotnet/System.Security.Principal.dll": {} + } + }, + "System.Text.Encoding/4.0.10": { + "type": "package", + "dependencies": { + "System.Runtime": "4.0.0" + }, + "compile": { + "ref/dotnet/System.Text.Encoding.dll": {} + }, + "runtime": { + "lib/DNXCore50/System.Text.Encoding.dll": {} + } + }, + "System.Text.Encoding.Extensions/4.0.10": { + "type": "package", + "dependencies": { + "System.Runtime": "4.0.0", + "System.Text.Encoding": "4.0.10" + }, + "compile": { + "ref/dotnet/System.Text.Encoding.Extensions.dll": {} + }, + "runtime": { + "lib/DNXCore50/System.Text.Encoding.Extensions.dll": {} + } + }, + "System.Text.RegularExpressions/4.0.10": { + "type": "package", + "dependencies": { + "System.Collections": "4.0.10", + "System.Globalization": "4.0.10", + "System.Resources.ResourceManager": "4.0.0", + "System.Runtime": "4.0.20", + "System.Runtime.Extensions": "4.0.10", + "System.Threading": "4.0.10" + }, + "compile": { + "ref/dotnet/System.Text.RegularExpressions.dll": {} + }, + "runtime": { + "lib/dotnet/System.Text.RegularExpressions.dll": {} + } + }, + "System.Threading/4.0.10": { + "type": "package", + "dependencies": { + "System.Runtime": "4.0.0", + "System.Threading.Tasks": "4.0.0" + }, + "compile": { + "ref/dotnet/System.Threading.dll": {} + }, + "runtime": { + "lib/DNXCore50/System.Threading.dll": {} + } + }, + "System.Threading.Overlapped/4.0.0": { + "type": "package", + "dependencies": { + "System.Runtime": "4.0.0", + "System.Runtime.Handles": "4.0.0" + }, + "compile": { + "ref/dotnet/System.Threading.Overlapped.dll": {} + }, + "runtime": { + "lib/DNXCore50/System.Threading.Overlapped.dll": {} + } + }, + "System.Threading.Tasks/4.0.10": { + "type": "package", + "dependencies": { + "System.Runtime": "4.0.0" + }, + "compile": { + "ref/dotnet/System.Threading.Tasks.dll": {} + }, + "runtime": { + "lib/DNXCore50/System.Threading.Tasks.dll": {} + } + }, + "System.Threading.Tasks.Dataflow/4.5.25": { + "type": "package", + "dependencies": { + "System.Collections": "4.0.0", + "System.Collections.Concurrent": "4.0.0", + "System.Diagnostics.Debug": "4.0.0", + "System.Diagnostics.Tracing": "4.0.0", + "System.Dynamic.Runtime": "4.0.0", + "System.Linq": "4.0.0", + "System.Resources.ResourceManager": "4.0.0", + "System.Runtime": "4.0.0", + "System.Runtime.Extensions": "4.0.0", + "System.Threading": "4.0.0", + "System.Threading.Tasks": "4.0.0" + }, + "compile": { + "lib/dotnet/System.Threading.Tasks.Dataflow.dll": {} + }, + "runtime": { + "lib/dotnet/System.Threading.Tasks.Dataflow.dll": {} + } + }, + "System.Threading.Tasks.Parallel/4.0.0": { + "type": "package", + "dependencies": { + "System.Collections.Concurrent": "4.0.10", + "System.Diagnostics.Debug": "4.0.10", + "System.Diagnostics.Tracing": "4.0.20", + "System.Resources.ResourceManager": "4.0.0", + "System.Runtime": "4.0.20", + "System.Runtime.Extensions": "4.0.10", + "System.Threading": "4.0.10", + "System.Threading.Tasks": "4.0.10" + }, + "compile": { + "ref/dotnet/System.Threading.Tasks.Parallel.dll": {} + }, + "runtime": { + "lib/dotnet/System.Threading.Tasks.Parallel.dll": {} + } + }, + "System.Threading.Timer/4.0.0": { + "type": "package", + "dependencies": { + "System.Runtime": "4.0.0" + }, + "compile": { + "ref/dotnet/System.Threading.Timer.dll": {} + }, + "runtime": { + "lib/DNXCore50/System.Threading.Timer.dll": {} + } + }, + "System.Xml.ReaderWriter/4.0.10": { + "type": "package", + "dependencies": { + "System.Collections": "4.0.10", + "System.Diagnostics.Debug": "4.0.10", + "System.Globalization": "4.0.10", + "System.IO": "4.0.10", + "System.IO.FileSystem": "4.0.0", + "System.IO.FileSystem.Primitives": "4.0.0", + "System.Resources.ResourceManager": "4.0.0", + "System.Runtime": "4.0.20", + "System.Runtime.Extensions": "4.0.10", + "System.Runtime.InteropServices": "4.0.20", + "System.Text.Encoding": "4.0.10", + "System.Text.Encoding.Extensions": "4.0.10", + "System.Text.RegularExpressions": "4.0.10", + "System.Threading.Tasks": "4.0.10" + }, + "compile": { + "ref/dotnet/System.Xml.ReaderWriter.dll": {} + }, + "runtime": { + "lib/dotnet/System.Xml.ReaderWriter.dll": {} + } + }, + "System.Xml.XDocument/4.0.10": { + "type": "package", + "dependencies": { + "System.Collections": "4.0.10", + "System.Diagnostics.Debug": "4.0.10", + "System.Globalization": "4.0.10", + "System.IO": "4.0.10", + "System.Reflection": "4.0.10", + "System.Resources.ResourceManager": "4.0.0", + "System.Runtime": "4.0.20", + "System.Runtime.Extensions": "4.0.10", + "System.Text.Encoding": "4.0.10", + "System.Threading": "4.0.10", + "System.Xml.ReaderWriter": "4.0.10" + }, + "compile": { + "ref/dotnet/System.Xml.XDocument.dll": {} + }, + "runtime": { + "lib/dotnet/System.Xml.XDocument.dll": {} + } + } + }, + "UAP,Version=v10.0": { + "Microsoft.CSharp/4.0.0": { + "type": "package", + "dependencies": { + "System.Collections": "4.0.10", + "System.Diagnostics.Debug": "4.0.10", + "System.Dynamic.Runtime": "4.0.0", + "System.Globalization": "4.0.10", + "System.Linq": "4.0.0", + "System.Linq.Expressions": "4.0.0", + "System.ObjectModel": "4.0.10", + "System.Reflection": "4.0.10", + "System.Reflection.Extensions": "4.0.0", + "System.Reflection.Primitives": "4.0.0", + "System.Reflection.TypeExtensions": "4.0.0", + "System.Resources.ResourceManager": "4.0.0", + "System.Runtime": "4.0.20", + "System.Runtime.Extensions": "4.0.10", + "System.Runtime.InteropServices": "4.0.20", + "System.Threading": "4.0.10" + }, + "compile": { + "ref/netcore50/Microsoft.CSharp.dll": {} + }, + "runtime": { + "lib/netcore50/Microsoft.CSharp.dll": {} + } + }, + "Microsoft.NETCore/5.0.0": { + "type": "package", + "dependencies": { + "Microsoft.CSharp": "4.0.0", + "Microsoft.NETCore.Targets": "1.0.0", + "Microsoft.VisualBasic": "10.0.0", + "System.AppContext": "4.0.0", + "System.Collections": "4.0.10", + "System.Collections.Concurrent": "4.0.10", + "System.Collections.Immutable": "1.1.37", + "System.ComponentModel": "4.0.0", + "System.ComponentModel.Annotations": "4.0.10", + "System.Diagnostics.Debug": "4.0.10", + "System.Diagnostics.Tools": "4.0.0", + "System.Diagnostics.Tracing": "4.0.20", + "System.Dynamic.Runtime": "4.0.10", + "System.Globalization": "4.0.10", + "System.Globalization.Calendars": "4.0.0", + "System.Globalization.Extensions": "4.0.0", + "System.IO": "4.0.10", + "System.IO.Compression": "4.0.0", + "System.IO.Compression.ZipFile": "4.0.0", + "System.IO.FileSystem": "4.0.0", + "System.IO.FileSystem.Primitives": "4.0.0", + "System.IO.UnmanagedMemoryStream": "4.0.0", + "System.Linq": "4.0.0", + "System.Linq.Expressions": "4.0.10", + "System.Linq.Parallel": "4.0.0", + "System.Linq.Queryable": "4.0.0", + "System.Net.Http": "4.0.0", + "System.Net.NetworkInformation": "4.0.0", + "System.Net.Primitives": "4.0.10", + "System.Numerics.Vectors": "4.1.0", + "System.ObjectModel": "4.0.10", + "System.Reflection": "4.0.10", + "System.Reflection.DispatchProxy": "4.0.0", + "System.Reflection.Extensions": "4.0.0", + "System.Reflection.Metadata": "1.0.22", + "System.Reflection.Primitives": "4.0.0", + "System.Reflection.TypeExtensions": "4.0.0", + "System.Resources.ResourceManager": "4.0.0", + "System.Runtime": "4.0.20", + "System.Runtime.Extensions": "4.0.10", + "System.Runtime.Handles": "4.0.0", + "System.Runtime.InteropServices": "4.0.20", + "System.Runtime.Numerics": "4.0.0", + "System.Security.Claims": "4.0.0", + "System.Security.Principal": "4.0.0", + "System.Text.Encoding": "4.0.10", + "System.Text.Encoding.Extensions": "4.0.10", + "System.Text.RegularExpressions": "4.0.10", + "System.Threading": "4.0.10", + "System.Threading.Tasks": "4.0.10", + "System.Threading.Tasks.Dataflow": "4.5.25", + "System.Threading.Tasks.Parallel": "4.0.0", + "System.Threading.Timer": "4.0.0", + "System.Xml.ReaderWriter": "4.0.10", + "System.Xml.XDocument": "4.0.10" + } + }, + "Microsoft.NETCore.Platforms/1.0.0": { + "type": "package" + }, + "Microsoft.NETCore.Portable.Compatibility/1.0.0": { + "type": "package", + "dependencies": { + "Microsoft.NETCore.Runtime": "1.0.0" + }, + "compile": { + "ref/netcore50/System.ComponentModel.DataAnnotations.dll": {}, + "ref/netcore50/System.Core.dll": {}, + "ref/netcore50/System.Net.dll": {}, + "ref/netcore50/System.Numerics.dll": {}, + "ref/netcore50/System.Runtime.Serialization.dll": {}, + "ref/netcore50/System.ServiceModel.Web.dll": {}, + "ref/netcore50/System.ServiceModel.dll": {}, + "ref/netcore50/System.Windows.dll": {}, + "ref/netcore50/System.Xml.Linq.dll": {}, + "ref/netcore50/System.Xml.Serialization.dll": {}, + "ref/netcore50/System.Xml.dll": {}, + "ref/netcore50/System.dll": {}, + "ref/netcore50/mscorlib.dll": {} + }, + "runtime": { + "lib/netcore50/System.ComponentModel.DataAnnotations.dll": {}, + "lib/netcore50/System.Core.dll": {}, + "lib/netcore50/System.Net.dll": {}, + "lib/netcore50/System.Numerics.dll": {}, + "lib/netcore50/System.Runtime.Serialization.dll": {}, + "lib/netcore50/System.ServiceModel.Web.dll": {}, + "lib/netcore50/System.ServiceModel.dll": {}, + "lib/netcore50/System.Windows.dll": {}, + "lib/netcore50/System.Xml.Linq.dll": {}, + "lib/netcore50/System.Xml.Serialization.dll": {}, + "lib/netcore50/System.Xml.dll": {}, + "lib/netcore50/System.dll": {} + }, + "runtimeTargets": { + "runtimes/aot/lib/netcore50/System.ComponentModel.DataAnnotations.dll": { + "assetType": "runtime", + "rid": "aot" + }, + "runtimes/aot/lib/netcore50/System.Core.dll": { + "assetType": "runtime", + "rid": "aot" + }, + "runtimes/aot/lib/netcore50/System.Net.dll": { + "assetType": "runtime", + "rid": "aot" + }, + "runtimes/aot/lib/netcore50/System.Numerics.dll": { + "assetType": "runtime", + "rid": "aot" + }, + "runtimes/aot/lib/netcore50/System.Runtime.Serialization.dll": { + "assetType": "runtime", + "rid": "aot" + }, + "runtimes/aot/lib/netcore50/System.ServiceModel.Web.dll": { + "assetType": "runtime", + "rid": "aot" + }, + "runtimes/aot/lib/netcore50/System.ServiceModel.dll": { + "assetType": "runtime", + "rid": "aot" + }, + "runtimes/aot/lib/netcore50/System.Windows.dll": { + "assetType": "runtime", + "rid": "aot" + }, + "runtimes/aot/lib/netcore50/System.Xml.Linq.dll": { + "assetType": "runtime", + "rid": "aot" + }, + "runtimes/aot/lib/netcore50/System.Xml.Serialization.dll": { + "assetType": "runtime", + "rid": "aot" + }, + "runtimes/aot/lib/netcore50/System.Xml.dll": { + "assetType": "runtime", + "rid": "aot" + }, + "runtimes/aot/lib/netcore50/System.dll": { + "assetType": "runtime", + "rid": "aot" + }, + "runtimes/aot/lib/netcore50/mscorlib.dll": { + "assetType": "runtime", + "rid": "aot" + } + } + }, + "Microsoft.NETCore.Runtime/1.0.0": { + "type": "package" + }, + "Microsoft.NETCore.Targets/1.0.0": { + "type": "package", + "dependencies": { + "Microsoft.NETCore.Platforms": "1.0.0", + "Microsoft.NETCore.Targets.UniversalWindowsPlatform": "5.0.0" + } + }, + "Microsoft.NETCore.Targets.UniversalWindowsPlatform/5.0.0": { + "type": "package" + }, + "Microsoft.VisualBasic/10.0.0": { + "type": "package", + "dependencies": { + "System.Collections": "4.0.10", + "System.Diagnostics.Debug": "4.0.10", + "System.Dynamic.Runtime": "4.0.10", + "System.Globalization": "4.0.10", + "System.Linq": "4.0.0", + "System.Linq.Expressions": "4.0.10", + "System.ObjectModel": "4.0.10", + "System.Reflection": "4.0.10", + "System.Reflection.Extensions": "4.0.0", + "System.Reflection.Primitives": "4.0.0", + "System.Reflection.TypeExtensions": "4.0.0", + "System.Resources.ResourceManager": "4.0.0", + "System.Runtime": "4.0.20", + "System.Runtime.Extensions": "4.0.10", + "System.Runtime.InteropServices": "4.0.20", + "System.Threading": "4.0.10" + }, + "compile": { + "ref/netcore50/Microsoft.VisualBasic.dll": {} + }, + "runtime": { + "lib/netcore50/Microsoft.VisualBasic.dll": {} + } + }, + "Microsoft.Win32.Primitives/4.0.0": { + "type": "package", + "dependencies": { + "System.Runtime": "4.0.20", + "System.Runtime.InteropServices": "4.0.20" + }, + "compile": { + "ref/dotnet/Microsoft.Win32.Primitives.dll": {} + }, + "runtime": { + "lib/dotnet/Microsoft.Win32.Primitives.dll": {} + } + }, + "System.AppContext/4.0.0": { + "type": "package", + "dependencies": { + "System.Collections": "4.0.0", + "System.Resources.ResourceManager": "4.0.0", + "System.Runtime": "4.0.20", + "System.Threading": "4.0.0" + }, + "compile": { + "ref/dotnet/System.AppContext.dll": {} + }, + "runtime": { + "lib/netcore50/System.AppContext.dll": {} + } + }, + "System.Collections/4.0.10": { + "type": "package", + "dependencies": { + "System.Diagnostics.Debug": "4.0.0", + "System.Resources.ResourceManager": "4.0.0", + "System.Runtime": "4.0.20", + "System.Runtime.Extensions": "4.0.0", + "System.Threading": "4.0.0" + }, + "compile": { + "ref/dotnet/System.Collections.dll": {} + }, + "runtime": { + "lib/netcore50/System.Collections.dll": {} + }, + "runtimeTargets": { + "runtimes/win8-aot/lib/netcore50/System.Collections.dll": { + "assetType": "runtime", + "rid": "win8-aot" + } + } + }, + "System.Collections.Concurrent/4.0.10": { + "type": "package", + "dependencies": { + "System.Collections": "4.0.10", + "System.Diagnostics.Debug": "4.0.10", + "System.Diagnostics.Tracing": "4.0.20", + "System.Globalization": "4.0.10", + "System.Resources.ResourceManager": "4.0.0", + "System.Runtime": "4.0.20", + "System.Runtime.Extensions": "4.0.10", + "System.Threading": "4.0.10", + "System.Threading.Tasks": "4.0.10" + }, + "compile": { + "ref/dotnet/System.Collections.Concurrent.dll": {} + }, + "runtime": { + "lib/dotnet/System.Collections.Concurrent.dll": {} + } + }, + "System.Collections.Immutable/1.1.37": { + "type": "package", + "dependencies": { + "System.Collections": "4.0.0", + "System.Diagnostics.Debug": "4.0.0", + "System.Globalization": "4.0.0", + "System.Linq": "4.0.0", + "System.Resources.ResourceManager": "4.0.0", + "System.Runtime": "4.0.0", + "System.Runtime.Extensions": "4.0.0", + "System.Threading": "4.0.0" + }, + "compile": { + "lib/dotnet/System.Collections.Immutable.dll": {} + }, + "runtime": { + "lib/dotnet/System.Collections.Immutable.dll": {} + } + }, + "System.Collections.NonGeneric/4.0.0": { + "type": "package", + "dependencies": { + "System.Diagnostics.Debug": "4.0.10", + "System.Globalization": "4.0.10", + "System.Resources.ResourceManager": "4.0.0", + "System.Runtime": "4.0.20", + "System.Runtime.Extensions": "4.0.10", + "System.Threading": "4.0.10" + }, + "compile": { + "ref/dotnet/System.Collections.NonGeneric.dll": {} + }, + "runtime": { + "lib/dotnet/System.Collections.NonGeneric.dll": {} + } + }, + "System.ComponentModel/4.0.0": { + "type": "package", + "dependencies": { + "System.Runtime": "4.0.20" + }, + "compile": { + "ref/netcore50/System.ComponentModel.dll": {} + }, + "runtime": { + "lib/netcore50/System.ComponentModel.dll": {} + } + }, + "System.ComponentModel.Annotations/4.0.10": { + "type": "package", + "dependencies": { + "System.Collections": "4.0.10", + "System.ComponentModel": "4.0.0", + "System.Globalization": "4.0.10", + "System.Linq": "4.0.0", + "System.Reflection": "4.0.10", + "System.Reflection.Extensions": "4.0.0", + "System.Resources.ResourceManager": "4.0.0", + "System.Runtime": "4.0.20", + "System.Runtime.Extensions": "4.0.10", + "System.Text.RegularExpressions": "4.0.10", + "System.Threading": "4.0.10" + }, + "compile": { + "ref/dotnet/System.ComponentModel.Annotations.dll": {} + }, + "runtime": { + "lib/dotnet/System.ComponentModel.Annotations.dll": {} + } + }, + "System.Diagnostics.Contracts/4.0.0": { + "type": "package", + "compile": { + "ref/netcore50/System.Diagnostics.Contracts.dll": {} + }, + "runtime": { + "lib/netcore50/System.Diagnostics.Contracts.dll": {} + }, + "runtimeTargets": { + "runtimes/win8-aot/lib/netcore50/System.Diagnostics.Contracts.dll": { + "assetType": "runtime", + "rid": "win8-aot" + } + } + }, + "System.Diagnostics.Debug/4.0.10": { + "type": "package", + "dependencies": { + "System.Runtime": "4.0.0" + }, + "compile": { + "ref/dotnet/System.Diagnostics.Debug.dll": {} + }, + "runtime": { + "lib/netcore50/System.Diagnostics.Debug.dll": {} + }, + "runtimeTargets": { + "runtimes/win8-aot/lib/netcore50/System.Diagnostics.Debug.dll": { + "assetType": "runtime", + "rid": "win8-aot" + } + } + }, + "System.Diagnostics.Tools/4.0.0": { + "type": "package", + "compile": { + "ref/netcore50/System.Diagnostics.Tools.dll": {} + }, + "runtime": { + "lib/netcore50/System.Diagnostics.Tools.dll": {} + }, + "runtimeTargets": { + "runtimes/win8-aot/lib/netcore50/System.Diagnostics.Tools.dll": { + "assetType": "runtime", + "rid": "win8-aot" + } + } + }, + "System.Diagnostics.Tracing/4.0.20": { + "type": "package", + "dependencies": { + "System.Collections": "4.0.10", + "System.Globalization": "4.0.0", + "System.Reflection": "4.0.10", + "System.Reflection.Extensions": "4.0.0", + "System.Resources.ResourceManager": "4.0.0", + "System.Runtime": "4.0.20", + "System.Runtime.Extensions": "4.0.10", + "System.Runtime.InteropServices": "4.0.0", + "System.Text.Encoding": "4.0.0", + "System.Threading": "4.0.10" + }, + "compile": { + "ref/dotnet/System.Diagnostics.Tracing.dll": {} + }, + "runtime": { + "lib/netcore50/System.Diagnostics.Tracing.dll": {} + }, + "runtimeTargets": { + "runtimes/win8-aot/lib/netcore50/System.Diagnostics.Tracing.dll": { + "assetType": "runtime", + "rid": "win8-aot" + } + } + }, + "System.Dynamic.Runtime/4.0.10": { + "type": "package", + "dependencies": { + "System.Collections": "4.0.0", + "System.Diagnostics.Debug": "4.0.0", + "System.Globalization": "4.0.0", + "System.Linq": "4.0.0", + "System.Linq.Expressions": "4.0.10", + "System.ObjectModel": "4.0.0", + "System.Reflection": "4.0.0", + "System.Reflection.TypeExtensions": "4.0.0", + "System.Resources.ResourceManager": "4.0.0", + "System.Runtime": "4.0.20", + "System.Runtime.Extensions": "4.0.0", + "System.Threading": "4.0.0" + }, + "compile": { + "ref/dotnet/System.Dynamic.Runtime.dll": {} + }, + "runtime": { + "lib/netcore50/System.Dynamic.Runtime.dll": {} + }, + "runtimeTargets": { + "runtimes/win8-aot/lib/netcore50/System.Dynamic.Runtime.dll": { + "assetType": "runtime", + "rid": "win8-aot" + } + } + }, + "System.Globalization/4.0.10": { + "type": "package", + "dependencies": { + "System.Runtime": "4.0.0" + }, + "compile": { + "ref/dotnet/System.Globalization.dll": {} + }, + "runtime": { + "lib/netcore50/System.Globalization.dll": {} + }, + "runtimeTargets": { + "runtimes/win8-aot/lib/netcore50/System.Globalization.dll": { + "assetType": "runtime", + "rid": "win8-aot" + } + } + }, + "System.Globalization.Calendars/4.0.0": { + "type": "package", + "dependencies": { + "System.Globalization": "4.0.0", + "System.Runtime": "4.0.0" + }, + "compile": { + "ref/dotnet/System.Globalization.Calendars.dll": {} + }, + "runtime": { + "lib/netcore50/System.Globalization.Calendars.dll": {} + }, + "runtimeTargets": { + "runtimes/win8-aot/lib/netcore50/System.Globalization.Calendars.dll": { + "assetType": "runtime", + "rid": "win8-aot" + } + } + }, + "System.Globalization.Extensions/4.0.0": { + "type": "package", + "dependencies": { + "System.Globalization": "4.0.10", + "System.Resources.ResourceManager": "4.0.0", + "System.Runtime": "4.0.20", + "System.Runtime.Extensions": "4.0.10", + "System.Runtime.InteropServices": "4.0.20" + }, + "compile": { + "ref/dotnet/System.Globalization.Extensions.dll": {} + }, + "runtime": { + "lib/dotnet/System.Globalization.Extensions.dll": {} + } + }, + "System.IO/4.0.10": { + "type": "package", + "dependencies": { + "System.Globalization": "4.0.0", + "System.Runtime": "4.0.20", + "System.Text.Encoding": "4.0.10", + "System.Text.Encoding.Extensions": "4.0.0", + "System.Threading": "4.0.0", + "System.Threading.Tasks": "4.0.0" + }, + "compile": { + "ref/dotnet/System.IO.dll": {} + }, + "runtime": { + "lib/netcore50/System.IO.dll": {} + }, + "runtimeTargets": { + "runtimes/win8-aot/lib/netcore50/System.IO.dll": { + "assetType": "runtime", + "rid": "win8-aot" + } + } + }, + "System.IO.Compression/4.0.0": { + "type": "package", + "dependencies": { + "System.Collections": "4.0.0", + "System.IO": "4.0.0", + "System.Resources.ResourceManager": "4.0.0", + "System.Runtime": "4.0.0", + "System.Runtime.Extensions": "4.0.0", + "System.Runtime.InteropServices": "4.0.0", + "System.Text.Encoding": "4.0.0", + "System.Threading": "4.0.0", + "System.Threading.Tasks": "4.0.0" + }, + "compile": { + "ref/netcore50/System.IO.Compression.dll": {} + }, + "runtime": { + "lib/netcore50/System.IO.Compression.dll": {} + } + }, + "System.IO.Compression.ZipFile/4.0.0": { + "type": "package", + "dependencies": { + "System.IO": "4.0.10", + "System.IO.Compression": "4.0.0", + "System.IO.FileSystem": "4.0.0", + "System.IO.FileSystem.Primitives": "4.0.0", + "System.Resources.ResourceManager": "4.0.0", + "System.Runtime": "4.0.20", + "System.Runtime.Extensions": "4.0.10", + "System.Text.Encoding": "4.0.10" + }, + "compile": { + "ref/dotnet/System.IO.Compression.ZipFile.dll": {} + }, + "runtime": { + "lib/dotnet/System.IO.Compression.ZipFile.dll": {} + } + }, + "System.IO.FileSystem/4.0.0": { + "type": "package", + "dependencies": { + "System.Collections": "4.0.10", + "System.Diagnostics.Debug": "4.0.10", + "System.IO": "4.0.10", + "System.IO.FileSystem.Primitives": "4.0.0", + "System.Resources.ResourceManager": "4.0.0", + "System.Runtime": "4.0.20", + "System.Runtime.Extensions": "4.0.10", + "System.Runtime.Handles": "4.0.0", + "System.Runtime.InteropServices": "4.0.20", + "System.Runtime.WindowsRuntime": "4.0.0", + "System.Text.Encoding": "4.0.10", + "System.Text.Encoding.Extensions": "4.0.10", + "System.Threading": "4.0.10", + "System.Threading.Overlapped": "4.0.0", + "System.Threading.Tasks": "4.0.10" + }, + "compile": { + "ref/dotnet/System.IO.FileSystem.dll": {} + }, + "runtime": { + "lib/netcore50/System.IO.FileSystem.dll": {} + } + }, + "System.IO.FileSystem.Primitives/4.0.0": { + "type": "package", + "dependencies": { + "System.Runtime": "4.0.20" + }, + "compile": { + "ref/dotnet/System.IO.FileSystem.Primitives.dll": {} + }, + "runtime": { + "lib/dotnet/System.IO.FileSystem.Primitives.dll": {} + } + }, + "System.IO.UnmanagedMemoryStream/4.0.0": { + "type": "package", + "dependencies": { + "System.IO": "4.0.10", + "System.IO.FileSystem.Primitives": "4.0.0", + "System.Resources.ResourceManager": "4.0.0", + "System.Runtime": "4.0.20", + "System.Runtime.InteropServices": "4.0.20", + "System.Threading": "4.0.10", + "System.Threading.Tasks": "4.0.10" + }, + "compile": { + "ref/dotnet/System.IO.UnmanagedMemoryStream.dll": {} + }, + "runtime": { + "lib/dotnet/System.IO.UnmanagedMemoryStream.dll": {} + } + }, + "System.Linq/4.0.0": { + "type": "package", + "dependencies": { + "System.Collections": "4.0.10", + "System.Diagnostics.Debug": "4.0.10", + "System.Resources.ResourceManager": "4.0.0", + "System.Runtime": "4.0.20", + "System.Runtime.Extensions": "4.0.10" + }, + "compile": { + "ref/netcore50/System.Linq.dll": {} + }, + "runtime": { + "lib/netcore50/System.Linq.dll": {} + } + }, + "System.Linq.Expressions/4.0.10": { + "type": "package", + "dependencies": { + "System.Collections": "4.0.0", + "System.Diagnostics.Debug": "4.0.0", + "System.Globalization": "4.0.0", + "System.IO": "4.0.0", + "System.Linq": "4.0.0", + "System.Reflection": "4.0.0", + "System.Reflection.Extensions": "4.0.0", + "System.Reflection.Primitives": "4.0.0", + "System.Reflection.TypeExtensions": "4.0.0", + "System.Resources.ResourceManager": "4.0.0", + "System.Runtime": "4.0.20", + "System.Runtime.Extensions": "4.0.0", + "System.Threading": "4.0.0" + }, + "compile": { + "ref/dotnet/System.Linq.Expressions.dll": {} + }, + "runtime": { + "lib/netcore50/System.Linq.Expressions.dll": {} + }, + "runtimeTargets": { + "runtimes/win8-aot/lib/netcore50/System.Linq.Expressions.dll": { + "assetType": "runtime", + "rid": "win8-aot" + } + } + }, + "System.Linq.Parallel/4.0.0": { + "type": "package", + "dependencies": { + "System.Collections": "4.0.10", + "System.Collections.Concurrent": "4.0.10", + "System.Diagnostics.Debug": "4.0.10", + "System.Diagnostics.Tracing": "4.0.20", + "System.Linq": "4.0.0", + "System.Resources.ResourceManager": "4.0.0", + "System.Runtime": "4.0.20", + "System.Runtime.Extensions": "4.0.10", + "System.Threading": "4.0.10", + "System.Threading.Tasks": "4.0.10" + }, + "compile": { + "ref/netcore50/System.Linq.Parallel.dll": {} + }, + "runtime": { + "lib/netcore50/System.Linq.Parallel.dll": {} + } + }, + "System.Linq.Queryable/4.0.0": { + "type": "package", + "dependencies": { + "System.Collections": "4.0.10", + "System.Linq": "4.0.0", + "System.Linq.Expressions": "4.0.10", + "System.Reflection": "4.0.10", + "System.Reflection.Extensions": "4.0.0", + "System.Resources.ResourceManager": "4.0.0", + "System.Runtime": "4.0.20" + }, + "compile": { + "ref/netcore50/System.Linq.Queryable.dll": {} + }, + "runtime": { + "lib/netcore50/System.Linq.Queryable.dll": {} + } + }, + "System.Net.Http/4.0.0": { + "type": "package", + "dependencies": { + "System.Collections": "4.0.10", + "System.Diagnostics.Debug": "4.0.10", + "System.Globalization": "4.0.10", + "System.IO": "4.0.10", + "System.Net.Primitives": "4.0.0", + "System.Resources.ResourceManager": "4.0.0", + "System.Runtime": "4.0.20", + "System.Runtime.Extensions": "4.0.10", + "System.Runtime.InteropServices": "4.0.20", + "System.Runtime.WindowsRuntime": "4.0.10", + "System.Text.Encoding": "4.0.10", + "System.Text.Encoding.Extensions": "4.0.10", + "System.Threading": "4.0.10", + "System.Threading.Tasks": "4.0.10" + }, + "compile": { + "ref/netcore50/System.Net.Http.dll": {} + }, + "runtime": { + "lib/netcore50/System.Net.Http.dll": {} + } + }, + "System.Net.NetworkInformation/4.0.0": { + "type": "package", + "dependencies": { + "System.Runtime": "4.0.0", + "System.Runtime.InteropServices.WindowsRuntime": "4.0.0", + "System.Threading": "4.0.0" + }, + "compile": { + "ref/netcore50/System.Net.NetworkInformation.dll": {} + }, + "runtime": { + "lib/netcore50/System.Net.NetworkInformation.dll": {} + } + }, + "System.Net.Primitives/4.0.10": { + "type": "package", + "dependencies": { + "System.Private.Networking": "4.0.0", + "System.Runtime": "4.0.20" + }, + "compile": { + "ref/dotnet/System.Net.Primitives.dll": {} + }, + "runtime": { + "lib/netcore50/System.Net.Primitives.dll": {} + } + }, + "System.Numerics.Vectors/4.1.0": { + "type": "package", + "dependencies": { + "System.Globalization": "4.0.10", + "System.Resources.ResourceManager": "4.0.0", + "System.Runtime": "4.0.20", + "System.Runtime.Extensions": "4.0.10" + }, + "compile": { + "ref/dotnet/System.Numerics.Vectors.dll": {} + }, + "runtime": { + "lib/dotnet/System.Numerics.Vectors.dll": {} + } + }, + "System.ObjectModel/4.0.10": { + "type": "package", + "dependencies": { + "System.Collections": "4.0.10", + "System.Diagnostics.Debug": "4.0.10", + "System.Resources.ResourceManager": "4.0.0", + "System.Runtime": "4.0.20", + "System.Threading": "4.0.10" + }, + "compile": { + "ref/dotnet/System.ObjectModel.dll": {} + }, + "runtime": { + "lib/dotnet/System.ObjectModel.dll": {} + } + }, + "System.Private.Networking/4.0.0": { + "type": "package", + "dependencies": { + "Microsoft.Win32.Primitives": "4.0.0", + "System.Collections": "4.0.10", + "System.Collections.NonGeneric": "4.0.0", + "System.Diagnostics.Debug": "4.0.10", + "System.Diagnostics.Tracing": "4.0.20", + "System.Globalization": "4.0.10", + "System.IO": "4.0.10", + "System.IO.FileSystem": "4.0.0", + "System.IO.FileSystem.Primitives": "4.0.0", + "System.Resources.ResourceManager": "4.0.0", + "System.Runtime": "4.0.20", + "System.Runtime.Extensions": "4.0.10", + "System.Runtime.Handles": "4.0.0", + "System.Runtime.InteropServices": "4.0.20", + "System.Threading": "4.0.10", + "System.Threading.Overlapped": "4.0.0", + "System.Threading.Tasks": "4.0.10" + }, + "compile": { + "ref/netcore50/_._": {} + }, + "runtime": { + "lib/netcore50/System.Private.Networking.dll": {} + } + }, + "System.Private.Uri/4.0.0": { + "type": "package", + "compile": { + "ref/netcore50/_._": {} + }, + "runtime": { + "lib/netcore50/System.Private.Uri.dll": {} + }, + "runtimeTargets": { + "runtimes/win8-aot/lib/netcore50/System.Private.Uri.dll": { + "assetType": "runtime", + "rid": "win8-aot" + } + } + }, + "System.Reflection/4.0.10": { + "type": "package", + "dependencies": { + "System.IO": "4.0.0", + "System.Reflection.Primitives": "4.0.0", + "System.Runtime": "4.0.20" + }, + "compile": { + "ref/dotnet/System.Reflection.dll": {} + }, + "runtime": { + "lib/netcore50/System.Reflection.dll": {} + }, + "runtimeTargets": { + "runtimes/win8-aot/lib/netcore50/System.Reflection.dll": { + "assetType": "runtime", + "rid": "win8-aot" + } + } + }, + "System.Reflection.DispatchProxy/4.0.0": { + "type": "package", + "dependencies": { + "System.Collections": "4.0.10", + "System.Linq": "4.0.0", + "System.Reflection": "4.0.10", + "System.Reflection.Extensions": "4.0.0", + "System.Reflection.Primitives": "4.0.0", + "System.Resources.ResourceManager": "4.0.0", + "System.Runtime": "4.0.20", + "System.Threading": "4.0.10" + }, + "compile": { + "ref/dotnet/System.Reflection.DispatchProxy.dll": {} + }, + "runtime": { + "lib/netcore50/System.Reflection.DispatchProxy.dll": {} + }, + "runtimeTargets": { + "runtimes/win8-aot/lib/netcore50/System.Reflection.DispatchProxy.dll": { + "assetType": "runtime", + "rid": "win8-aot" + } + } + }, + "System.Reflection.Extensions/4.0.0": { + "type": "package", + "dependencies": { + "System.Diagnostics.Debug": "4.0.10", + "System.Reflection": "4.0.10", + "System.Reflection.Primitives": "4.0.0", + "System.Reflection.TypeExtensions": "4.0.0", + "System.Resources.ResourceManager": "4.0.0", + "System.Runtime": "4.0.20", + "System.Runtime.Extensions": "4.0.10" + }, + "compile": { + "ref/netcore50/System.Reflection.Extensions.dll": {} + }, + "runtime": { + "lib/netcore50/System.Reflection.Extensions.dll": {} + }, + "runtimeTargets": { + "runtimes/win8-aot/lib/netcore50/System.Reflection.Extensions.dll": { + "assetType": "runtime", + "rid": "win8-aot" + } + } + }, + "System.Reflection.Metadata/1.0.22": { + "type": "package", + "dependencies": { + "System.Collections": "4.0.0", + "System.Collections.Immutable": "1.1.37", + "System.Diagnostics.Debug": "4.0.0", + "System.IO": "4.0.0", + "System.Reflection": "4.0.0", + "System.Reflection.Extensions": "4.0.0", + "System.Reflection.Primitives": "4.0.0", + "System.Resources.ResourceManager": "4.0.0", + "System.Runtime": "4.0.0", + "System.Runtime.Extensions": "4.0.0", + "System.Runtime.InteropServices": "4.0.0", + "System.Text.Encoding": "4.0.0", + "System.Text.Encoding.Extensions": "4.0.0", + "System.Threading": "4.0.0" + }, + "compile": { + "lib/dotnet/System.Reflection.Metadata.dll": {} + }, + "runtime": { + "lib/dotnet/System.Reflection.Metadata.dll": {} + } + }, + "System.Reflection.Primitives/4.0.0": { + "type": "package", + "dependencies": { + "System.Runtime": "4.0.0", + "System.Threading": "4.0.0" + }, + "compile": { + "ref/netcore50/System.Reflection.Primitives.dll": {} + }, + "runtime": { + "lib/netcore50/System.Reflection.Primitives.dll": {} + }, + "runtimeTargets": { + "runtimes/win8-aot/lib/netcore50/System.Reflection.Primitives.dll": { + "assetType": "runtime", + "rid": "win8-aot" + } + } + }, + "System.Reflection.TypeExtensions/4.0.0": { + "type": "package", + "dependencies": { + "System.Diagnostics.Contracts": "4.0.0", + "System.Diagnostics.Debug": "4.0.10", + "System.Linq": "4.0.0", + "System.Reflection": "4.0.10", + "System.Reflection.Primitives": "4.0.0", + "System.Resources.ResourceManager": "4.0.0", + "System.Runtime": "4.0.20", + "System.Runtime.Extensions": "4.0.10" + }, + "compile": { + "ref/dotnet/System.Reflection.TypeExtensions.dll": {} + }, + "runtime": { + "lib/netcore50/System.Reflection.TypeExtensions.dll": {} + }, + "runtimeTargets": { + "runtimes/win8-aot/lib/netcore50/System.Reflection.TypeExtensions.dll": { + "assetType": "runtime", + "rid": "win8-aot" + } + } + }, + "System.Resources.ResourceManager/4.0.0": { + "type": "package", + "dependencies": { + "System.Globalization": "4.0.0", + "System.Reflection": "4.0.10", + "System.Runtime": "4.0.20" + }, + "compile": { + "ref/netcore50/System.Resources.ResourceManager.dll": {} + }, + "runtime": { + "lib/netcore50/System.Resources.ResourceManager.dll": {} + }, + "runtimeTargets": { + "runtimes/win8-aot/lib/netcore50/System.Resources.ResourceManager.dll": { + "assetType": "runtime", + "rid": "win8-aot" + } + } + }, + "System.Runtime/4.0.20": { + "type": "package", + "dependencies": { + "System.Private.Uri": "4.0.0" + }, + "compile": { + "ref/dotnet/System.Runtime.dll": {} + }, + "runtime": { + "lib/netcore50/System.Runtime.dll": {} + }, + "runtimeTargets": { + "runtimes/win8-aot/lib/netcore50/System.Runtime.dll": { + "assetType": "runtime", + "rid": "win8-aot" + } + } + }, + "System.Runtime.Extensions/4.0.10": { + "type": "package", + "dependencies": { + "System.Runtime": "4.0.20" + }, + "compile": { + "ref/dotnet/System.Runtime.Extensions.dll": {} + }, + "runtime": { + "lib/netcore50/System.Runtime.Extensions.dll": {} + }, + "runtimeTargets": { + "runtimes/win8-aot/lib/netcore50/System.Runtime.Extensions.dll": { + "assetType": "runtime", + "rid": "win8-aot" + } + } + }, + "System.Runtime.Handles/4.0.0": { + "type": "package", + "dependencies": { + "System.Runtime": "4.0.0" + }, + "compile": { + "ref/dotnet/System.Runtime.Handles.dll": {} + }, + "runtime": { + "lib/netcore50/System.Runtime.Handles.dll": {} + }, + "runtimeTargets": { + "runtimes/win8-aot/lib/netcore50/System.Runtime.Handles.dll": { + "assetType": "runtime", + "rid": "win8-aot" + } + } + }, + "System.Runtime.InteropServices/4.0.20": { + "type": "package", + "dependencies": { + "System.Reflection": "4.0.0", + "System.Reflection.Primitives": "4.0.0", + "System.Runtime": "4.0.0", + "System.Runtime.Handles": "4.0.0" + }, + "compile": { + "ref/dotnet/System.Runtime.InteropServices.dll": {} + }, + "runtime": { + "lib/netcore50/System.Runtime.InteropServices.dll": {} + }, + "runtimeTargets": { + "runtimes/win8-aot/lib/netcore50/System.Runtime.InteropServices.dll": { + "assetType": "runtime", + "rid": "win8-aot" + } + } + }, + "System.Runtime.InteropServices.WindowsRuntime/4.0.0": { + "type": "package", + "compile": { + "ref/netcore50/System.Runtime.InteropServices.WindowsRuntime.dll": {} + }, + "runtime": { + "lib/netcore50/System.Runtime.InteropServices.WindowsRuntime.dll": {} + }, + "runtimeTargets": { + "runtimes/win8-aot/lib/netcore50/System.Runtime.InteropServices.WindowsRuntime.dll": { + "assetType": "runtime", + "rid": "win8-aot" + } + } + }, + "System.Runtime.Numerics/4.0.0": { + "type": "package", + "dependencies": { + "System.Globalization": "4.0.10", + "System.Resources.ResourceManager": "4.0.0", + "System.Runtime": "4.0.20", + "System.Runtime.Extensions": "4.0.10" + }, + "compile": { + "ref/netcore50/System.Runtime.Numerics.dll": {} + }, + "runtime": { + "lib/netcore50/System.Runtime.Numerics.dll": {} + } + }, + "System.Runtime.WindowsRuntime/4.0.10": { + "type": "package", + "dependencies": { + "System.Diagnostics.Debug": "4.0.10", + "System.Globalization": "4.0.0", + "System.IO": "4.0.10", + "System.ObjectModel": "4.0.0", + "System.Resources.ResourceManager": "4.0.0", + "System.Runtime": "4.0.20", + "System.Runtime.Extensions": "4.0.0", + "System.Runtime.InteropServices": "4.0.20", + "System.Threading": "4.0.10", + "System.Threading.Tasks": "4.0.10" + }, + "compile": { + "ref/netcore50/System.Runtime.WindowsRuntime.dll": {} + }, + "runtime": { + "lib/netcore50/System.Runtime.WindowsRuntime.dll": {} + }, + "runtimeTargets": { + "runtimes/win8-aot/lib/netcore50/System.Runtime.WindowsRuntime.dll": { + "assetType": "runtime", + "rid": "win8-aot" + } + } + }, + "System.Security.Claims/4.0.0": { + "type": "package", + "dependencies": { + "System.Collections": "4.0.0", + "System.Diagnostics.Debug": "4.0.0", + "System.Globalization": "4.0.0", + "System.IO": "4.0.0", + "System.Resources.ResourceManager": "4.0.0", + "System.Runtime": "4.0.20", + "System.Runtime.Extensions": "4.0.0", + "System.Security.Principal": "4.0.0" + }, + "compile": { + "ref/dotnet/System.Security.Claims.dll": {} + }, + "runtime": { + "lib/dotnet/System.Security.Claims.dll": {} + } + }, + "System.Security.Principal/4.0.0": { + "type": "package", + "dependencies": { + "System.Runtime": "4.0.0" + }, + "compile": { + "ref/netcore50/System.Security.Principal.dll": {} + }, + "runtime": { + "lib/netcore50/System.Security.Principal.dll": {} + } + }, + "System.Text.Encoding/4.0.10": { + "type": "package", + "dependencies": { + "System.Runtime": "4.0.0" + }, + "compile": { + "ref/dotnet/System.Text.Encoding.dll": {} + }, + "runtime": { + "lib/netcore50/System.Text.Encoding.dll": {} + }, + "runtimeTargets": { + "runtimes/win8-aot/lib/netcore50/System.Text.Encoding.dll": { + "assetType": "runtime", + "rid": "win8-aot" + } + } + }, + "System.Text.Encoding.Extensions/4.0.10": { + "type": "package", + "dependencies": { + "System.Runtime": "4.0.0", + "System.Text.Encoding": "4.0.10" + }, + "compile": { + "ref/dotnet/System.Text.Encoding.Extensions.dll": {} + }, + "runtime": { + "lib/netcore50/System.Text.Encoding.Extensions.dll": {} + }, + "runtimeTargets": { + "runtimes/win8-aot/lib/netcore50/System.Text.Encoding.Extensions.dll": { + "assetType": "runtime", + "rid": "win8-aot" + } + } + }, + "System.Text.RegularExpressions/4.0.10": { + "type": "package", + "dependencies": { + "System.Collections": "4.0.10", + "System.Globalization": "4.0.10", + "System.Resources.ResourceManager": "4.0.0", + "System.Runtime": "4.0.20", + "System.Runtime.Extensions": "4.0.10", + "System.Threading": "4.0.10" + }, + "compile": { + "ref/dotnet/System.Text.RegularExpressions.dll": {} + }, + "runtime": { + "lib/dotnet/System.Text.RegularExpressions.dll": {} + } + }, + "System.Threading/4.0.10": { + "type": "package", + "dependencies": { + "System.Runtime": "4.0.0", + "System.Threading.Tasks": "4.0.0" + }, + "compile": { + "ref/dotnet/System.Threading.dll": {} + }, + "runtime": { + "lib/netcore50/System.Threading.dll": {} + }, + "runtimeTargets": { + "runtimes/win8-aot/lib/netcore50/System.Threading.dll": { + "assetType": "runtime", + "rid": "win8-aot" + } + } + }, + "System.Threading.Overlapped/4.0.0": { + "type": "package", + "dependencies": { + "System.Resources.ResourceManager": "4.0.0", + "System.Runtime": "4.0.20", + "System.Runtime.Extensions": "4.0.0", + "System.Runtime.Handles": "4.0.0", + "System.Runtime.InteropServices": "4.0.20", + "System.Threading": "4.0.10" + }, + "compile": { + "ref/dotnet/System.Threading.Overlapped.dll": {} + }, + "runtime": { + "lib/netcore50/System.Threading.Overlapped.dll": {} + } + }, + "System.Threading.Tasks/4.0.10": { + "type": "package", + "dependencies": { + "System.Runtime": "4.0.0" + }, + "compile": { + "ref/dotnet/System.Threading.Tasks.dll": {} + }, + "runtime": { + "lib/netcore50/System.Threading.Tasks.dll": {} + }, + "runtimeTargets": { + "runtimes/win8-aot/lib/netcore50/System.Threading.Tasks.dll": { + "assetType": "runtime", + "rid": "win8-aot" + } + } + }, + "System.Threading.Tasks.Dataflow/4.5.25": { + "type": "package", + "dependencies": { + "System.Collections": "4.0.0", + "System.Collections.Concurrent": "4.0.0", + "System.Diagnostics.Debug": "4.0.0", + "System.Diagnostics.Tracing": "4.0.0", + "System.Dynamic.Runtime": "4.0.0", + "System.Linq": "4.0.0", + "System.Resources.ResourceManager": "4.0.0", + "System.Runtime": "4.0.0", + "System.Runtime.Extensions": "4.0.0", + "System.Threading": "4.0.0", + "System.Threading.Tasks": "4.0.0" + }, + "compile": { + "lib/dotnet/System.Threading.Tasks.Dataflow.dll": {} + }, + "runtime": { + "lib/dotnet/System.Threading.Tasks.Dataflow.dll": {} + } + }, + "System.Threading.Tasks.Parallel/4.0.0": { + "type": "package", + "dependencies": { + "System.Collections.Concurrent": "4.0.10", + "System.Diagnostics.Debug": "4.0.10", + "System.Diagnostics.Tracing": "4.0.20", + "System.Resources.ResourceManager": "4.0.0", + "System.Runtime": "4.0.20", + "System.Runtime.Extensions": "4.0.10", + "System.Threading": "4.0.10", + "System.Threading.Tasks": "4.0.10" + }, + "compile": { + "ref/netcore50/System.Threading.Tasks.Parallel.dll": {} + }, + "runtime": { + "lib/netcore50/System.Threading.Tasks.Parallel.dll": {} + } + }, + "System.Threading.Timer/4.0.0": { + "type": "package", + "compile": { + "ref/netcore50/System.Threading.Timer.dll": {} + }, + "runtime": { + "lib/netcore50/System.Threading.Timer.dll": {} + }, + "runtimeTargets": { + "runtimes/win8-aot/lib/netcore50/System.Threading.Timer.dll": { + "assetType": "runtime", + "rid": "win8-aot" + } + } + }, + "System.Xml.ReaderWriter/4.0.10": { + "type": "package", + "dependencies": { + "System.Collections": "4.0.10", + "System.Diagnostics.Debug": "4.0.10", + "System.Globalization": "4.0.10", + "System.IO": "4.0.10", + "System.IO.FileSystem": "4.0.0", + "System.IO.FileSystem.Primitives": "4.0.0", + "System.Resources.ResourceManager": "4.0.0", + "System.Runtime": "4.0.20", + "System.Runtime.Extensions": "4.0.10", + "System.Runtime.InteropServices": "4.0.20", + "System.Text.Encoding": "4.0.10", + "System.Text.Encoding.Extensions": "4.0.10", + "System.Text.RegularExpressions": "4.0.10", + "System.Threading.Tasks": "4.0.10" + }, + "compile": { + "ref/dotnet/System.Xml.ReaderWriter.dll": {} + }, + "runtime": { + "lib/dotnet/System.Xml.ReaderWriter.dll": {} + } + }, + "System.Xml.XDocument/4.0.10": { + "type": "package", + "dependencies": { + "System.Collections": "4.0.10", + "System.Diagnostics.Debug": "4.0.10", + "System.Globalization": "4.0.10", + "System.IO": "4.0.10", + "System.Reflection": "4.0.10", + "System.Resources.ResourceManager": "4.0.0", + "System.Runtime": "4.0.20", + "System.Runtime.Extensions": "4.0.10", + "System.Text.Encoding": "4.0.10", + "System.Threading": "4.0.10", + "System.Xml.ReaderWriter": "4.0.10" + }, + "compile": { + "ref/dotnet/System.Xml.XDocument.dll": {} + }, + "runtime": { + "lib/dotnet/System.Xml.XDocument.dll": {} + } + } + }, + "UAP,Version=v10.0/win10-arm": { + "Microsoft.CSharp/4.0.0": { + "type": "package", + "dependencies": { + "System.Collections": "4.0.10", + "System.Diagnostics.Debug": "4.0.10", + "System.Dynamic.Runtime": "4.0.0", + "System.Globalization": "4.0.10", + "System.Linq": "4.0.0", + "System.Linq.Expressions": "4.0.0", + "System.ObjectModel": "4.0.10", + "System.Reflection": "4.0.10", + "System.Reflection.Extensions": "4.0.0", + "System.Reflection.Primitives": "4.0.0", + "System.Reflection.TypeExtensions": "4.0.0", + "System.Resources.ResourceManager": "4.0.0", + "System.Runtime": "4.0.20", + "System.Runtime.Extensions": "4.0.10", + "System.Runtime.InteropServices": "4.0.20", + "System.Threading": "4.0.10" + }, + "compile": { + "ref/netcore50/Microsoft.CSharp.dll": {} + }, + "runtime": { + "lib/netcore50/Microsoft.CSharp.dll": {} + } + }, + "Microsoft.NETCore/5.0.0": { + "type": "package", + "dependencies": { + "Microsoft.CSharp": "4.0.0", + "Microsoft.NETCore.Targets": "1.0.0", + "Microsoft.VisualBasic": "10.0.0", + "System.AppContext": "4.0.0", + "System.Collections": "4.0.10", + "System.Collections.Concurrent": "4.0.10", + "System.Collections.Immutable": "1.1.37", + "System.ComponentModel": "4.0.0", + "System.ComponentModel.Annotations": "4.0.10", + "System.Diagnostics.Debug": "4.0.10", + "System.Diagnostics.Tools": "4.0.0", + "System.Diagnostics.Tracing": "4.0.20", + "System.Dynamic.Runtime": "4.0.10", + "System.Globalization": "4.0.10", + "System.Globalization.Calendars": "4.0.0", + "System.Globalization.Extensions": "4.0.0", + "System.IO": "4.0.10", + "System.IO.Compression": "4.0.0", + "System.IO.Compression.ZipFile": "4.0.0", + "System.IO.FileSystem": "4.0.0", + "System.IO.FileSystem.Primitives": "4.0.0", + "System.IO.UnmanagedMemoryStream": "4.0.0", + "System.Linq": "4.0.0", + "System.Linq.Expressions": "4.0.10", + "System.Linq.Parallel": "4.0.0", + "System.Linq.Queryable": "4.0.0", + "System.Net.Http": "4.0.0", + "System.Net.NetworkInformation": "4.0.0", + "System.Net.Primitives": "4.0.10", + "System.Numerics.Vectors": "4.1.0", + "System.ObjectModel": "4.0.10", + "System.Reflection": "4.0.10", + "System.Reflection.DispatchProxy": "4.0.0", + "System.Reflection.Extensions": "4.0.0", + "System.Reflection.Metadata": "1.0.22", + "System.Reflection.Primitives": "4.0.0", + "System.Reflection.TypeExtensions": "4.0.0", + "System.Resources.ResourceManager": "4.0.0", + "System.Runtime": "4.0.20", + "System.Runtime.Extensions": "4.0.10", + "System.Runtime.Handles": "4.0.0", + "System.Runtime.InteropServices": "4.0.20", + "System.Runtime.Numerics": "4.0.0", + "System.Security.Claims": "4.0.0", + "System.Security.Principal": "4.0.0", + "System.Text.Encoding": "4.0.10", + "System.Text.Encoding.Extensions": "4.0.10", + "System.Text.RegularExpressions": "4.0.10", + "System.Threading": "4.0.10", + "System.Threading.Tasks": "4.0.10", + "System.Threading.Tasks.Dataflow": "4.5.25", + "System.Threading.Tasks.Parallel": "4.0.0", + "System.Threading.Timer": "4.0.0", + "System.Xml.ReaderWriter": "4.0.10", + "System.Xml.XDocument": "4.0.10" + } + }, + "Microsoft.NETCore.Platforms/1.0.0": { + "type": "package" + }, + "Microsoft.NETCore.Portable.Compatibility/1.0.0": { + "type": "package", + "dependencies": { + "Microsoft.NETCore.Runtime": "1.0.0" + }, + "compile": { + "ref/netcore50/System.ComponentModel.DataAnnotations.dll": {}, + "ref/netcore50/System.Core.dll": {}, + "ref/netcore50/System.Net.dll": {}, + "ref/netcore50/System.Numerics.dll": {}, + "ref/netcore50/System.Runtime.Serialization.dll": {}, + "ref/netcore50/System.ServiceModel.Web.dll": {}, + "ref/netcore50/System.ServiceModel.dll": {}, + "ref/netcore50/System.Windows.dll": {}, + "ref/netcore50/System.Xml.Linq.dll": {}, + "ref/netcore50/System.Xml.Serialization.dll": {}, + "ref/netcore50/System.Xml.dll": {}, + "ref/netcore50/System.dll": {}, + "ref/netcore50/mscorlib.dll": {} + }, + "runtime": { + "lib/netcore50/System.ComponentModel.DataAnnotations.dll": {}, + "lib/netcore50/System.Core.dll": {}, + "lib/netcore50/System.Net.dll": {}, + "lib/netcore50/System.Numerics.dll": {}, + "lib/netcore50/System.Runtime.Serialization.dll": {}, + "lib/netcore50/System.ServiceModel.Web.dll": {}, + "lib/netcore50/System.ServiceModel.dll": {}, + "lib/netcore50/System.Windows.dll": {}, + "lib/netcore50/System.Xml.Linq.dll": {}, + "lib/netcore50/System.Xml.Serialization.dll": {}, + "lib/netcore50/System.Xml.dll": {}, + "lib/netcore50/System.dll": {} + } + }, + "Microsoft.NETCore.Runtime/1.0.0": { + "type": "package", + "dependencies": { + "Microsoft.NETCore.Runtime.CoreCLR-arm": "1.0.0" + } + }, + "Microsoft.NETCore.Runtime.CoreCLR-arm/1.0.0": { + "type": "package", + "dependencies": { + "System.Collections": "[4.0.10]", + "System.Diagnostics.Contracts": "[4.0.0]", + "System.Diagnostics.Debug": "[4.0.10]", + "System.Diagnostics.StackTrace": "[4.0.0]", + "System.Diagnostics.Tools": "[4.0.0]", + "System.Diagnostics.Tracing": "[4.0.20]", + "System.Globalization": "[4.0.10]", + "System.Globalization.Calendars": "[4.0.0]", + "System.IO": "[4.0.10]", + "System.ObjectModel": "[4.0.10]", + "System.Private.Uri": "[4.0.0]", + "System.Reflection": "[4.0.10]", + "System.Reflection.Extensions": "[4.0.0]", + "System.Reflection.Primitives": "[4.0.0]", + "System.Resources.ResourceManager": "[4.0.0]", + "System.Runtime": "[4.0.20]", + "System.Runtime.Extensions": "[4.0.10]", + "System.Runtime.Handles": "[4.0.0]", + "System.Runtime.InteropServices": "[4.0.20]", + "System.Text.Encoding": "[4.0.10]", + "System.Text.Encoding.Extensions": "[4.0.10]", + "System.Threading": "[4.0.10]", + "System.Threading.Tasks": "[4.0.10]", + "System.Threading.Timer": "[4.0.0]" + }, + "compile": { + "ref/dotnet/_._": {} + }, + "runtime": { + "runtimes/win8-arm/lib/dotnet/mscorlib.ni.dll": {} + }, + "native": { + "runtimes/win8-arm/native/clretwrc.dll": {}, + "runtimes/win8-arm/native/coreclr.dll": {}, + "runtimes/win8-arm/native/dbgshim.dll": {}, + "runtimes/win8-arm/native/mscordaccore.dll": {}, + "runtimes/win8-arm/native/mscordbi.dll": {}, + "runtimes/win8-arm/native/mscorrc.debug.dll": {}, + "runtimes/win8-arm/native/mscorrc.dll": {} + } + }, + "Microsoft.NETCore.Targets/1.0.0": { + "type": "package", + "dependencies": { + "Microsoft.NETCore.Platforms": "1.0.0", + "Microsoft.NETCore.Targets.UniversalWindowsPlatform": "5.0.0" + } + }, + "Microsoft.NETCore.Targets.UniversalWindowsPlatform/5.0.0": { + "type": "package" + }, + "Microsoft.VisualBasic/10.0.0": { + "type": "package", + "dependencies": { + "System.Collections": "4.0.10", + "System.Diagnostics.Debug": "4.0.10", + "System.Dynamic.Runtime": "4.0.10", + "System.Globalization": "4.0.10", + "System.Linq": "4.0.0", + "System.Linq.Expressions": "4.0.10", + "System.ObjectModel": "4.0.10", + "System.Reflection": "4.0.10", + "System.Reflection.Extensions": "4.0.0", + "System.Reflection.Primitives": "4.0.0", + "System.Reflection.TypeExtensions": "4.0.0", + "System.Resources.ResourceManager": "4.0.0", + "System.Runtime": "4.0.20", + "System.Runtime.Extensions": "4.0.10", + "System.Runtime.InteropServices": "4.0.20", + "System.Threading": "4.0.10" + }, + "compile": { + "ref/netcore50/Microsoft.VisualBasic.dll": {} + }, + "runtime": { + "lib/netcore50/Microsoft.VisualBasic.dll": {} + } + }, + "Microsoft.Win32.Primitives/4.0.0": { + "type": "package", + "dependencies": { + "System.Runtime": "4.0.20", + "System.Runtime.InteropServices": "4.0.20" + }, + "compile": { + "ref/dotnet/Microsoft.Win32.Primitives.dll": {} + }, + "runtime": { + "lib/dotnet/Microsoft.Win32.Primitives.dll": {} + } + }, + "System.AppContext/4.0.0": { + "type": "package", + "dependencies": { + "System.Collections": "4.0.0", + "System.Resources.ResourceManager": "4.0.0", + "System.Runtime": "4.0.20", + "System.Threading": "4.0.0" + }, + "compile": { + "ref/dotnet/System.AppContext.dll": {} + }, + "runtime": { + "lib/netcore50/System.AppContext.dll": {} + } + }, + "System.Collections/4.0.10": { + "type": "package", + "dependencies": { + "System.Diagnostics.Debug": "4.0.0", + "System.Resources.ResourceManager": "4.0.0", + "System.Runtime": "4.0.20", + "System.Runtime.Extensions": "4.0.0", + "System.Threading": "4.0.0" + }, + "compile": { + "ref/dotnet/System.Collections.dll": {} + }, + "runtime": { + "lib/netcore50/System.Collections.dll": {} + } + }, + "System.Collections.Concurrent/4.0.10": { + "type": "package", + "dependencies": { + "System.Collections": "4.0.10", + "System.Diagnostics.Debug": "4.0.10", + "System.Diagnostics.Tracing": "4.0.20", + "System.Globalization": "4.0.10", + "System.Resources.ResourceManager": "4.0.0", + "System.Runtime": "4.0.20", + "System.Runtime.Extensions": "4.0.10", + "System.Threading": "4.0.10", + "System.Threading.Tasks": "4.0.10" + }, + "compile": { + "ref/dotnet/System.Collections.Concurrent.dll": {} + }, + "runtime": { + "lib/dotnet/System.Collections.Concurrent.dll": {} + } + }, + "System.Collections.Immutable/1.1.37": { + "type": "package", + "dependencies": { + "System.Collections": "4.0.0", + "System.Diagnostics.Debug": "4.0.0", + "System.Globalization": "4.0.0", + "System.Linq": "4.0.0", + "System.Resources.ResourceManager": "4.0.0", + "System.Runtime": "4.0.0", + "System.Runtime.Extensions": "4.0.0", + "System.Threading": "4.0.0" + }, + "compile": { + "lib/dotnet/System.Collections.Immutable.dll": {} + }, + "runtime": { + "lib/dotnet/System.Collections.Immutable.dll": {} + } + }, + "System.Collections.NonGeneric/4.0.0": { + "type": "package", + "dependencies": { + "System.Diagnostics.Debug": "4.0.10", + "System.Globalization": "4.0.10", + "System.Resources.ResourceManager": "4.0.0", + "System.Runtime": "4.0.20", + "System.Runtime.Extensions": "4.0.10", + "System.Threading": "4.0.10" + }, + "compile": { + "ref/dotnet/System.Collections.NonGeneric.dll": {} + }, + "runtime": { + "lib/dotnet/System.Collections.NonGeneric.dll": {} + } + }, + "System.ComponentModel/4.0.0": { + "type": "package", + "dependencies": { + "System.Runtime": "4.0.20" + }, + "compile": { + "ref/netcore50/System.ComponentModel.dll": {} + }, + "runtime": { + "lib/netcore50/System.ComponentModel.dll": {} + } + }, + "System.ComponentModel.Annotations/4.0.10": { + "type": "package", + "dependencies": { + "System.Collections": "4.0.10", + "System.ComponentModel": "4.0.0", + "System.Globalization": "4.0.10", + "System.Linq": "4.0.0", + "System.Reflection": "4.0.10", + "System.Reflection.Extensions": "4.0.0", + "System.Resources.ResourceManager": "4.0.0", + "System.Runtime": "4.0.20", + "System.Runtime.Extensions": "4.0.10", + "System.Text.RegularExpressions": "4.0.10", + "System.Threading": "4.0.10" + }, + "compile": { + "ref/dotnet/System.ComponentModel.Annotations.dll": {} + }, + "runtime": { + "lib/dotnet/System.ComponentModel.Annotations.dll": {} + } + }, + "System.Diagnostics.Contracts/4.0.0": { + "type": "package", + "compile": { + "ref/netcore50/System.Diagnostics.Contracts.dll": {} + }, + "runtime": { + "lib/netcore50/System.Diagnostics.Contracts.dll": {} + } + }, + "System.Diagnostics.Debug/4.0.10": { + "type": "package", + "dependencies": { + "System.Runtime": "4.0.0" + }, + "compile": { + "ref/dotnet/System.Diagnostics.Debug.dll": {} + }, + "runtime": { + "lib/netcore50/System.Diagnostics.Debug.dll": {} + } + }, + "System.Diagnostics.StackTrace/4.0.0": { + "type": "package", + "dependencies": { + "System.Runtime": "4.0.20" + }, + "compile": { + "ref/dotnet/System.Diagnostics.StackTrace.dll": {} + }, + "runtime": { + "lib/netcore50/System.Diagnostics.StackTrace.dll": {} + } + }, + "System.Diagnostics.Tools/4.0.0": { + "type": "package", + "compile": { + "ref/netcore50/System.Diagnostics.Tools.dll": {} + }, + "runtime": { + "lib/netcore50/System.Diagnostics.Tools.dll": {} + } + }, + "System.Diagnostics.Tracing/4.0.20": { + "type": "package", + "dependencies": { + "System.Collections": "4.0.10", + "System.Globalization": "4.0.0", + "System.Reflection": "4.0.10", + "System.Reflection.Extensions": "4.0.0", + "System.Resources.ResourceManager": "4.0.0", + "System.Runtime": "4.0.20", + "System.Runtime.Extensions": "4.0.10", + "System.Runtime.InteropServices": "4.0.0", + "System.Text.Encoding": "4.0.0", + "System.Threading": "4.0.10" + }, + "compile": { + "ref/dotnet/System.Diagnostics.Tracing.dll": {} + }, + "runtime": { + "lib/netcore50/System.Diagnostics.Tracing.dll": {} + } + }, + "System.Dynamic.Runtime/4.0.10": { + "type": "package", + "dependencies": { + "System.Collections": "4.0.0", + "System.Diagnostics.Debug": "4.0.0", + "System.Globalization": "4.0.0", + "System.Linq": "4.0.0", + "System.Linq.Expressions": "4.0.10", + "System.ObjectModel": "4.0.0", + "System.Reflection": "4.0.0", + "System.Reflection.Emit.ILGeneration": "4.0.0", + "System.Reflection.Emit.Lightweight": "4.0.0", + "System.Reflection.TypeExtensions": "4.0.0", + "System.Resources.ResourceManager": "4.0.0", + "System.Runtime": "4.0.20", + "System.Runtime.Extensions": "4.0.0", + "System.Threading": "4.0.0" + }, + "compile": { + "ref/dotnet/System.Dynamic.Runtime.dll": {} + }, + "runtime": { + "lib/netcore50/System.Dynamic.Runtime.dll": {} + } + }, + "System.Globalization/4.0.10": { + "type": "package", + "dependencies": { + "System.Runtime": "4.0.0" + }, + "compile": { + "ref/dotnet/System.Globalization.dll": {} + }, + "runtime": { + "lib/netcore50/System.Globalization.dll": {} + } + }, + "System.Globalization.Calendars/4.0.0": { + "type": "package", + "dependencies": { + "System.Globalization": "4.0.0", + "System.Runtime": "4.0.0" + }, + "compile": { + "ref/dotnet/System.Globalization.Calendars.dll": {} + }, + "runtime": { + "lib/netcore50/System.Globalization.Calendars.dll": {} + } + }, + "System.Globalization.Extensions/4.0.0": { + "type": "package", + "dependencies": { + "System.Globalization": "4.0.10", + "System.Resources.ResourceManager": "4.0.0", + "System.Runtime": "4.0.20", + "System.Runtime.Extensions": "4.0.10", + "System.Runtime.InteropServices": "4.0.20" + }, + "compile": { + "ref/dotnet/System.Globalization.Extensions.dll": {} + }, + "runtime": { + "lib/dotnet/System.Globalization.Extensions.dll": {} + } + }, + "System.IO/4.0.10": { + "type": "package", + "dependencies": { + "System.Globalization": "4.0.0", + "System.Runtime": "4.0.20", + "System.Text.Encoding": "4.0.10", + "System.Text.Encoding.Extensions": "4.0.0", + "System.Threading": "4.0.0", + "System.Threading.Tasks": "4.0.0" + }, + "compile": { + "ref/dotnet/System.IO.dll": {} + }, + "runtime": { + "lib/netcore50/System.IO.dll": {} + } + }, + "System.IO.Compression/4.0.0": { + "type": "package", + "dependencies": { + "System.Collections": "4.0.0", + "System.IO": "4.0.0", + "System.IO.Compression.clrcompression-arm": "4.0.0", + "System.Resources.ResourceManager": "4.0.0", + "System.Runtime": "4.0.0", + "System.Runtime.Extensions": "4.0.0", + "System.Runtime.InteropServices": "4.0.0", + "System.Text.Encoding": "4.0.0", + "System.Threading": "4.0.0", + "System.Threading.Tasks": "4.0.0" + }, + "compile": { + "ref/netcore50/System.IO.Compression.dll": {} + }, + "runtime": { + "lib/netcore50/System.IO.Compression.dll": {} + } + }, + "System.IO.Compression.clrcompression-arm/4.0.0": { + "type": "package", + "native": { + "runtimes/win10-arm/native/ClrCompression.dll": {} + } + }, + "System.IO.Compression.ZipFile/4.0.0": { + "type": "package", + "dependencies": { + "System.IO": "4.0.10", + "System.IO.Compression": "4.0.0", + "System.IO.FileSystem": "4.0.0", + "System.IO.FileSystem.Primitives": "4.0.0", + "System.Resources.ResourceManager": "4.0.0", + "System.Runtime": "4.0.20", + "System.Runtime.Extensions": "4.0.10", + "System.Text.Encoding": "4.0.10" + }, + "compile": { + "ref/dotnet/System.IO.Compression.ZipFile.dll": {} + }, + "runtime": { + "lib/dotnet/System.IO.Compression.ZipFile.dll": {} + } + }, + "System.IO.FileSystem/4.0.0": { + "type": "package", + "dependencies": { + "System.Collections": "4.0.10", + "System.Diagnostics.Debug": "4.0.10", + "System.IO": "4.0.10", + "System.IO.FileSystem.Primitives": "4.0.0", + "System.Resources.ResourceManager": "4.0.0", + "System.Runtime": "4.0.20", + "System.Runtime.Extensions": "4.0.10", + "System.Runtime.Handles": "4.0.0", + "System.Runtime.InteropServices": "4.0.20", + "System.Runtime.WindowsRuntime": "4.0.0", + "System.Text.Encoding": "4.0.10", + "System.Text.Encoding.Extensions": "4.0.10", + "System.Threading": "4.0.10", + "System.Threading.Overlapped": "4.0.0", + "System.Threading.Tasks": "4.0.10" + }, + "compile": { + "ref/dotnet/System.IO.FileSystem.dll": {} + }, + "runtime": { + "lib/netcore50/System.IO.FileSystem.dll": {} + } + }, + "System.IO.FileSystem.Primitives/4.0.0": { + "type": "package", + "dependencies": { + "System.Runtime": "4.0.20" + }, + "compile": { + "ref/dotnet/System.IO.FileSystem.Primitives.dll": {} + }, + "runtime": { + "lib/dotnet/System.IO.FileSystem.Primitives.dll": {} + } + }, + "System.IO.UnmanagedMemoryStream/4.0.0": { + "type": "package", + "dependencies": { + "System.IO": "4.0.10", + "System.IO.FileSystem.Primitives": "4.0.0", + "System.Resources.ResourceManager": "4.0.0", + "System.Runtime": "4.0.20", + "System.Runtime.InteropServices": "4.0.20", + "System.Threading": "4.0.10", + "System.Threading.Tasks": "4.0.10" + }, + "compile": { + "ref/dotnet/System.IO.UnmanagedMemoryStream.dll": {} + }, + "runtime": { + "lib/dotnet/System.IO.UnmanagedMemoryStream.dll": {} + } + }, + "System.Linq/4.0.0": { + "type": "package", + "dependencies": { + "System.Collections": "4.0.10", + "System.Diagnostics.Debug": "4.0.10", + "System.Resources.ResourceManager": "4.0.0", + "System.Runtime": "4.0.20", + "System.Runtime.Extensions": "4.0.10" + }, + "compile": { + "ref/netcore50/System.Linq.dll": {} + }, + "runtime": { + "lib/netcore50/System.Linq.dll": {} + } + }, + "System.Linq.Expressions/4.0.10": { + "type": "package", + "dependencies": { + "System.Collections": "4.0.0", + "System.Diagnostics.Debug": "4.0.0", + "System.Globalization": "4.0.0", + "System.IO": "4.0.0", + "System.Linq": "4.0.0", + "System.Reflection": "4.0.0", + "System.Reflection.Emit.ILGeneration": "4.0.0", + "System.Reflection.Emit.Lightweight": "4.0.0", + "System.Reflection.Extensions": "4.0.0", + "System.Reflection.Primitives": "4.0.0", + "System.Reflection.TypeExtensions": "4.0.0", + "System.Resources.ResourceManager": "4.0.0", + "System.Runtime": "4.0.20", + "System.Runtime.Extensions": "4.0.0", + "System.Threading": "4.0.0" + }, + "compile": { + "ref/dotnet/System.Linq.Expressions.dll": {} + }, + "runtime": { + "lib/netcore50/System.Linq.Expressions.dll": {} + } + }, + "System.Linq.Parallel/4.0.0": { + "type": "package", + "dependencies": { + "System.Collections": "4.0.10", + "System.Collections.Concurrent": "4.0.10", + "System.Diagnostics.Debug": "4.0.10", + "System.Diagnostics.Tracing": "4.0.20", + "System.Linq": "4.0.0", + "System.Resources.ResourceManager": "4.0.0", + "System.Runtime": "4.0.20", + "System.Runtime.Extensions": "4.0.10", + "System.Threading": "4.0.10", + "System.Threading.Tasks": "4.0.10" + }, + "compile": { + "ref/netcore50/System.Linq.Parallel.dll": {} + }, + "runtime": { + "lib/netcore50/System.Linq.Parallel.dll": {} + } + }, + "System.Linq.Queryable/4.0.0": { + "type": "package", + "dependencies": { + "System.Collections": "4.0.10", + "System.Linq": "4.0.0", + "System.Linq.Expressions": "4.0.10", + "System.Reflection": "4.0.10", + "System.Reflection.Extensions": "4.0.0", + "System.Resources.ResourceManager": "4.0.0", + "System.Runtime": "4.0.20" + }, + "compile": { + "ref/netcore50/System.Linq.Queryable.dll": {} + }, + "runtime": { + "lib/netcore50/System.Linq.Queryable.dll": {} + } + }, + "System.Net.Http/4.0.0": { + "type": "package", + "dependencies": { + "System.Collections": "4.0.10", + "System.Diagnostics.Debug": "4.0.10", + "System.Globalization": "4.0.10", + "System.IO": "4.0.10", + "System.Net.Primitives": "4.0.0", + "System.Resources.ResourceManager": "4.0.0", + "System.Runtime": "4.0.20", + "System.Runtime.Extensions": "4.0.10", + "System.Runtime.InteropServices": "4.0.20", + "System.Runtime.WindowsRuntime": "4.0.10", + "System.Text.Encoding": "4.0.10", + "System.Text.Encoding.Extensions": "4.0.10", + "System.Threading": "4.0.10", + "System.Threading.Tasks": "4.0.10" + }, + "compile": { + "ref/netcore50/System.Net.Http.dll": {} + }, + "runtime": { + "lib/netcore50/System.Net.Http.dll": {} + } + }, + "System.Net.NetworkInformation/4.0.0": { + "type": "package", + "dependencies": { + "System.Runtime": "4.0.0", + "System.Runtime.InteropServices.WindowsRuntime": "4.0.0", + "System.Threading": "4.0.0" + }, + "compile": { + "ref/netcore50/System.Net.NetworkInformation.dll": {} + }, + "runtime": { + "lib/netcore50/System.Net.NetworkInformation.dll": {} + } + }, + "System.Net.Primitives/4.0.10": { + "type": "package", + "dependencies": { + "System.Private.Networking": "4.0.0", + "System.Runtime": "4.0.20" + }, + "compile": { + "ref/dotnet/System.Net.Primitives.dll": {} + }, + "runtime": { + "lib/netcore50/System.Net.Primitives.dll": {} + } + }, + "System.Numerics.Vectors/4.1.0": { + "type": "package", + "dependencies": { + "System.Globalization": "4.0.10", + "System.Resources.ResourceManager": "4.0.0", + "System.Runtime": "4.0.20", + "System.Runtime.Extensions": "4.0.10" + }, + "compile": { + "ref/dotnet/System.Numerics.Vectors.dll": {} + }, + "runtime": { + "lib/dotnet/System.Numerics.Vectors.dll": {} + } + }, + "System.ObjectModel/4.0.10": { + "type": "package", + "dependencies": { + "System.Collections": "4.0.10", + "System.Diagnostics.Debug": "4.0.10", + "System.Resources.ResourceManager": "4.0.0", + "System.Runtime": "4.0.20", + "System.Threading": "4.0.10" + }, + "compile": { + "ref/dotnet/System.ObjectModel.dll": {} + }, + "runtime": { + "lib/dotnet/System.ObjectModel.dll": {} + } + }, + "System.Private.Networking/4.0.0": { + "type": "package", + "dependencies": { + "Microsoft.Win32.Primitives": "4.0.0", + "System.Collections": "4.0.10", + "System.Collections.NonGeneric": "4.0.0", + "System.Diagnostics.Debug": "4.0.10", + "System.Diagnostics.Tracing": "4.0.20", + "System.Globalization": "4.0.10", + "System.IO": "4.0.10", + "System.IO.FileSystem": "4.0.0", + "System.IO.FileSystem.Primitives": "4.0.0", + "System.Resources.ResourceManager": "4.0.0", + "System.Runtime": "4.0.20", + "System.Runtime.Extensions": "4.0.10", + "System.Runtime.Handles": "4.0.0", + "System.Runtime.InteropServices": "4.0.20", + "System.Threading": "4.0.10", + "System.Threading.Overlapped": "4.0.0", + "System.Threading.Tasks": "4.0.10" + }, + "compile": { + "ref/netcore50/_._": {} + }, + "runtime": { + "lib/netcore50/System.Private.Networking.dll": {} + } + }, + "System.Private.Uri/4.0.0": { + "type": "package", + "compile": { + "ref/netcore50/_._": {} + }, + "runtime": { + "lib/netcore50/System.Private.Uri.dll": {} + } + }, + "System.Reflection/4.0.10": { + "type": "package", + "dependencies": { + "System.IO": "4.0.0", + "System.Reflection.Primitives": "4.0.0", + "System.Runtime": "4.0.20" + }, + "compile": { + "ref/dotnet/System.Reflection.dll": {} + }, + "runtime": { + "lib/netcore50/System.Reflection.dll": {} + } + }, + "System.Reflection.DispatchProxy/4.0.0": { + "type": "package", + "dependencies": { + "System.Collections": "4.0.10", + "System.Linq": "4.0.0", + "System.Reflection": "4.0.10", + "System.Reflection.Emit": "4.0.0", + "System.Reflection.Emit.ILGeneration": "4.0.0", + "System.Reflection.Extensions": "4.0.0", + "System.Reflection.Primitives": "4.0.0", + "System.Resources.ResourceManager": "4.0.0", + "System.Runtime": "4.0.20", + "System.Threading": "4.0.10" + }, + "compile": { + "ref/dotnet/System.Reflection.DispatchProxy.dll": {} + }, + "runtime": { + "lib/netcore50/System.Reflection.DispatchProxy.dll": {} + } + }, + "System.Reflection.Emit/4.0.0": { + "type": "package", + "dependencies": { + "System.IO": "4.0.0", + "System.Reflection": "4.0.0", + "System.Reflection.Emit.ILGeneration": "4.0.0", + "System.Reflection.Primitives": "4.0.0", + "System.Runtime": "4.0.0" + }, + "compile": { + "ref/dotnet/System.Reflection.Emit.dll": {} + }, + "runtime": { + "lib/netcore50/System.Reflection.Emit.dll": {} + } + }, + "System.Reflection.Emit.ILGeneration/4.0.0": { + "type": "package", + "dependencies": { + "System.Reflection": "4.0.0", + "System.Reflection.Primitives": "4.0.0", + "System.Runtime": "4.0.0" + }, + "compile": { + "ref/dotnet/System.Reflection.Emit.ILGeneration.dll": {} + }, + "runtime": { + "lib/netcore50/System.Reflection.Emit.ILGeneration.dll": {} + } + }, + "System.Reflection.Emit.Lightweight/4.0.0": { + "type": "package", + "dependencies": { + "System.Reflection": "4.0.0", + "System.Reflection.Emit.ILGeneration": "4.0.0", + "System.Reflection.Primitives": "4.0.0", + "System.Runtime": "4.0.0" + }, + "compile": { + "ref/dotnet/System.Reflection.Emit.Lightweight.dll": {} + }, + "runtime": { + "lib/netcore50/System.Reflection.Emit.Lightweight.dll": {} + } + }, + "System.Reflection.Extensions/4.0.0": { + "type": "package", + "dependencies": { + "System.Diagnostics.Debug": "4.0.10", + "System.Reflection": "4.0.10", + "System.Reflection.Primitives": "4.0.0", + "System.Reflection.TypeExtensions": "4.0.0", + "System.Resources.ResourceManager": "4.0.0", + "System.Runtime": "4.0.20", + "System.Runtime.Extensions": "4.0.10" + }, + "compile": { + "ref/netcore50/System.Reflection.Extensions.dll": {} + }, + "runtime": { + "lib/netcore50/System.Reflection.Extensions.dll": {} + } + }, + "System.Reflection.Metadata/1.0.22": { + "type": "package", + "dependencies": { + "System.Collections": "4.0.0", + "System.Collections.Immutable": "1.1.37", + "System.Diagnostics.Debug": "4.0.0", + "System.IO": "4.0.0", + "System.Reflection": "4.0.0", + "System.Reflection.Extensions": "4.0.0", + "System.Reflection.Primitives": "4.0.0", + "System.Resources.ResourceManager": "4.0.0", + "System.Runtime": "4.0.0", + "System.Runtime.Extensions": "4.0.0", + "System.Runtime.InteropServices": "4.0.0", + "System.Text.Encoding": "4.0.0", + "System.Text.Encoding.Extensions": "4.0.0", + "System.Threading": "4.0.0" + }, + "compile": { + "lib/dotnet/System.Reflection.Metadata.dll": {} + }, + "runtime": { + "lib/dotnet/System.Reflection.Metadata.dll": {} + } + }, + "System.Reflection.Primitives/4.0.0": { + "type": "package", + "dependencies": { + "System.Runtime": "4.0.0", + "System.Threading": "4.0.0" + }, + "compile": { + "ref/netcore50/System.Reflection.Primitives.dll": {} + }, + "runtime": { + "lib/netcore50/System.Reflection.Primitives.dll": {} + } + }, + "System.Reflection.TypeExtensions/4.0.0": { + "type": "package", + "dependencies": { + "System.Diagnostics.Contracts": "4.0.0", + "System.Diagnostics.Debug": "4.0.10", + "System.Linq": "4.0.0", + "System.Reflection": "4.0.10", + "System.Reflection.Primitives": "4.0.0", + "System.Resources.ResourceManager": "4.0.0", + "System.Runtime": "4.0.20", + "System.Runtime.Extensions": "4.0.10" + }, + "compile": { + "ref/dotnet/System.Reflection.TypeExtensions.dll": {} + }, + "runtime": { + "lib/netcore50/System.Reflection.TypeExtensions.dll": {} + } + }, + "System.Resources.ResourceManager/4.0.0": { + "type": "package", + "dependencies": { + "System.Globalization": "4.0.0", + "System.Reflection": "4.0.10", + "System.Runtime": "4.0.20" + }, + "compile": { + "ref/netcore50/System.Resources.ResourceManager.dll": {} + }, + "runtime": { + "lib/netcore50/System.Resources.ResourceManager.dll": {} + } + }, + "System.Runtime/4.0.20": { + "type": "package", + "dependencies": { + "System.Private.Uri": "4.0.0" + }, + "compile": { + "ref/dotnet/System.Runtime.dll": {} + }, + "runtime": { + "lib/netcore50/System.Runtime.dll": {} + } + }, + "System.Runtime.Extensions/4.0.10": { + "type": "package", + "dependencies": { + "System.Runtime": "4.0.20" + }, + "compile": { + "ref/dotnet/System.Runtime.Extensions.dll": {} + }, + "runtime": { + "lib/netcore50/System.Runtime.Extensions.dll": {} + } + }, + "System.Runtime.Handles/4.0.0": { + "type": "package", + "dependencies": { + "System.Runtime": "4.0.0" + }, + "compile": { + "ref/dotnet/System.Runtime.Handles.dll": {} + }, + "runtime": { + "lib/netcore50/System.Runtime.Handles.dll": {} + } + }, + "System.Runtime.InteropServices/4.0.20": { + "type": "package", + "dependencies": { + "System.Reflection": "4.0.0", + "System.Reflection.Primitives": "4.0.0", + "System.Runtime": "4.0.0", + "System.Runtime.Handles": "4.0.0" + }, + "compile": { + "ref/dotnet/System.Runtime.InteropServices.dll": {} + }, + "runtime": { + "lib/netcore50/System.Runtime.InteropServices.dll": {} + } + }, + "System.Runtime.InteropServices.WindowsRuntime/4.0.0": { + "type": "package", + "compile": { + "ref/netcore50/System.Runtime.InteropServices.WindowsRuntime.dll": {} + }, + "runtime": { + "lib/netcore50/System.Runtime.InteropServices.WindowsRuntime.dll": {} + } + }, + "System.Runtime.Numerics/4.0.0": { + "type": "package", + "dependencies": { + "System.Globalization": "4.0.10", + "System.Resources.ResourceManager": "4.0.0", + "System.Runtime": "4.0.20", + "System.Runtime.Extensions": "4.0.10" + }, + "compile": { + "ref/netcore50/System.Runtime.Numerics.dll": {} + }, + "runtime": { + "lib/netcore50/System.Runtime.Numerics.dll": {} + } + }, + "System.Runtime.WindowsRuntime/4.0.10": { + "type": "package", + "dependencies": { + "System.Diagnostics.Debug": "4.0.10", + "System.Globalization": "4.0.0", + "System.IO": "4.0.10", + "System.ObjectModel": "4.0.0", + "System.Resources.ResourceManager": "4.0.0", + "System.Runtime": "4.0.20", + "System.Runtime.Extensions": "4.0.0", + "System.Runtime.InteropServices": "4.0.20", + "System.Threading": "4.0.10", + "System.Threading.Tasks": "4.0.10" + }, + "compile": { + "ref/netcore50/System.Runtime.WindowsRuntime.dll": {} + }, + "runtime": { + "lib/netcore50/System.Runtime.WindowsRuntime.dll": {} + } + }, + "System.Security.Claims/4.0.0": { + "type": "package", + "dependencies": { + "System.Collections": "4.0.0", + "System.Diagnostics.Debug": "4.0.0", + "System.Globalization": "4.0.0", + "System.IO": "4.0.0", + "System.Resources.ResourceManager": "4.0.0", + "System.Runtime": "4.0.20", + "System.Runtime.Extensions": "4.0.0", + "System.Security.Principal": "4.0.0" + }, + "compile": { + "ref/dotnet/System.Security.Claims.dll": {} + }, + "runtime": { + "lib/dotnet/System.Security.Claims.dll": {} + } + }, + "System.Security.Principal/4.0.0": { + "type": "package", + "dependencies": { + "System.Runtime": "4.0.0" + }, + "compile": { + "ref/netcore50/System.Security.Principal.dll": {} + }, + "runtime": { + "lib/netcore50/System.Security.Principal.dll": {} + } + }, + "System.Text.Encoding/4.0.10": { + "type": "package", + "dependencies": { + "System.Runtime": "4.0.0" + }, + "compile": { + "ref/dotnet/System.Text.Encoding.dll": {} + }, + "runtime": { + "lib/netcore50/System.Text.Encoding.dll": {} + } + }, + "System.Text.Encoding.Extensions/4.0.10": { + "type": "package", + "dependencies": { + "System.Runtime": "4.0.0", + "System.Text.Encoding": "4.0.10" + }, + "compile": { + "ref/dotnet/System.Text.Encoding.Extensions.dll": {} + }, + "runtime": { + "lib/netcore50/System.Text.Encoding.Extensions.dll": {} + } + }, + "System.Text.RegularExpressions/4.0.10": { + "type": "package", + "dependencies": { + "System.Collections": "4.0.10", + "System.Globalization": "4.0.10", + "System.Resources.ResourceManager": "4.0.0", + "System.Runtime": "4.0.20", + "System.Runtime.Extensions": "4.0.10", + "System.Threading": "4.0.10" + }, + "compile": { + "ref/dotnet/System.Text.RegularExpressions.dll": {} + }, + "runtime": { + "lib/dotnet/System.Text.RegularExpressions.dll": {} + } + }, + "System.Threading/4.0.10": { + "type": "package", + "dependencies": { + "System.Runtime": "4.0.0", + "System.Threading.Tasks": "4.0.0" + }, + "compile": { + "ref/dotnet/System.Threading.dll": {} + }, + "runtime": { + "lib/netcore50/System.Threading.dll": {} + } + }, + "System.Threading.Overlapped/4.0.0": { + "type": "package", + "dependencies": { + "System.Resources.ResourceManager": "4.0.0", + "System.Runtime": "4.0.20", + "System.Runtime.Extensions": "4.0.0", + "System.Runtime.Handles": "4.0.0", + "System.Runtime.InteropServices": "4.0.20", + "System.Threading": "4.0.10" + }, + "compile": { + "ref/dotnet/System.Threading.Overlapped.dll": {} + }, + "runtime": { + "lib/netcore50/System.Threading.Overlapped.dll": {} + } + }, + "System.Threading.Tasks/4.0.10": { + "type": "package", + "dependencies": { + "System.Runtime": "4.0.0" + }, + "compile": { + "ref/dotnet/System.Threading.Tasks.dll": {} + }, + "runtime": { + "lib/netcore50/System.Threading.Tasks.dll": {} + } + }, + "System.Threading.Tasks.Dataflow/4.5.25": { + "type": "package", + "dependencies": { + "System.Collections": "4.0.0", + "System.Collections.Concurrent": "4.0.0", + "System.Diagnostics.Debug": "4.0.0", + "System.Diagnostics.Tracing": "4.0.0", + "System.Dynamic.Runtime": "4.0.0", + "System.Linq": "4.0.0", + "System.Resources.ResourceManager": "4.0.0", + "System.Runtime": "4.0.0", + "System.Runtime.Extensions": "4.0.0", + "System.Threading": "4.0.0", + "System.Threading.Tasks": "4.0.0" + }, + "compile": { + "lib/dotnet/System.Threading.Tasks.Dataflow.dll": {} + }, + "runtime": { + "lib/dotnet/System.Threading.Tasks.Dataflow.dll": {} + } + }, + "System.Threading.Tasks.Parallel/4.0.0": { + "type": "package", + "dependencies": { + "System.Collections.Concurrent": "4.0.10", + "System.Diagnostics.Debug": "4.0.10", + "System.Diagnostics.Tracing": "4.0.20", + "System.Resources.ResourceManager": "4.0.0", + "System.Runtime": "4.0.20", + "System.Runtime.Extensions": "4.0.10", + "System.Threading": "4.0.10", + "System.Threading.Tasks": "4.0.10" + }, + "compile": { + "ref/netcore50/System.Threading.Tasks.Parallel.dll": {} + }, + "runtime": { + "lib/netcore50/System.Threading.Tasks.Parallel.dll": {} + } + }, + "System.Threading.Timer/4.0.0": { + "type": "package", + "compile": { + "ref/netcore50/System.Threading.Timer.dll": {} + }, + "runtime": { + "lib/netcore50/System.Threading.Timer.dll": {} + } + }, + "System.Xml.ReaderWriter/4.0.10": { + "type": "package", + "dependencies": { + "System.Collections": "4.0.10", + "System.Diagnostics.Debug": "4.0.10", + "System.Globalization": "4.0.10", + "System.IO": "4.0.10", + "System.IO.FileSystem": "4.0.0", + "System.IO.FileSystem.Primitives": "4.0.0", + "System.Resources.ResourceManager": "4.0.0", + "System.Runtime": "4.0.20", + "System.Runtime.Extensions": "4.0.10", + "System.Runtime.InteropServices": "4.0.20", + "System.Text.Encoding": "4.0.10", + "System.Text.Encoding.Extensions": "4.0.10", + "System.Text.RegularExpressions": "4.0.10", + "System.Threading.Tasks": "4.0.10" + }, + "compile": { + "ref/dotnet/System.Xml.ReaderWriter.dll": {} + }, + "runtime": { + "lib/dotnet/System.Xml.ReaderWriter.dll": {} + } + }, + "System.Xml.XDocument/4.0.10": { + "type": "package", + "dependencies": { + "System.Collections": "4.0.10", + "System.Diagnostics.Debug": "4.0.10", + "System.Globalization": "4.0.10", + "System.IO": "4.0.10", + "System.Reflection": "4.0.10", + "System.Resources.ResourceManager": "4.0.0", + "System.Runtime": "4.0.20", + "System.Runtime.Extensions": "4.0.10", + "System.Text.Encoding": "4.0.10", + "System.Threading": "4.0.10", + "System.Xml.ReaderWriter": "4.0.10" + }, + "compile": { + "ref/dotnet/System.Xml.XDocument.dll": {} + }, + "runtime": { + "lib/dotnet/System.Xml.XDocument.dll": {} + } + } + }, + "UAP,Version=v10.0/win10-arm-aot": { + "Microsoft.CSharp/4.0.0": { + "type": "package", + "dependencies": { + "System.Collections": "4.0.10", + "System.Diagnostics.Debug": "4.0.10", + "System.Dynamic.Runtime": "4.0.0", + "System.Globalization": "4.0.10", + "System.Linq": "4.0.0", + "System.Linq.Expressions": "4.0.0", + "System.ObjectModel": "4.0.10", + "System.Reflection": "4.0.10", + "System.Reflection.Extensions": "4.0.0", + "System.Reflection.Primitives": "4.0.0", + "System.Reflection.TypeExtensions": "4.0.0", + "System.Resources.ResourceManager": "4.0.0", + "System.Runtime": "4.0.20", + "System.Runtime.Extensions": "4.0.10", + "System.Runtime.InteropServices": "4.0.20", + "System.Threading": "4.0.10" + }, + "compile": { + "ref/netcore50/Microsoft.CSharp.dll": {} + }, + "runtime": { + "lib/netcore50/Microsoft.CSharp.dll": {} + } + }, + "Microsoft.NETCore/5.0.0": { + "type": "package", + "dependencies": { + "Microsoft.CSharp": "4.0.0", + "Microsoft.NETCore.Targets": "1.0.0", + "Microsoft.VisualBasic": "10.0.0", + "System.AppContext": "4.0.0", + "System.Collections": "4.0.10", + "System.Collections.Concurrent": "4.0.10", + "System.Collections.Immutable": "1.1.37", + "System.ComponentModel": "4.0.0", + "System.ComponentModel.Annotations": "4.0.10", + "System.Diagnostics.Debug": "4.0.10", + "System.Diagnostics.Tools": "4.0.0", + "System.Diagnostics.Tracing": "4.0.20", + "System.Dynamic.Runtime": "4.0.10", + "System.Globalization": "4.0.10", + "System.Globalization.Calendars": "4.0.0", + "System.Globalization.Extensions": "4.0.0", + "System.IO": "4.0.10", + "System.IO.Compression": "4.0.0", + "System.IO.Compression.ZipFile": "4.0.0", + "System.IO.FileSystem": "4.0.0", + "System.IO.FileSystem.Primitives": "4.0.0", + "System.IO.UnmanagedMemoryStream": "4.0.0", + "System.Linq": "4.0.0", + "System.Linq.Expressions": "4.0.10", + "System.Linq.Parallel": "4.0.0", + "System.Linq.Queryable": "4.0.0", + "System.Net.Http": "4.0.0", + "System.Net.NetworkInformation": "4.0.0", + "System.Net.Primitives": "4.0.10", + "System.Numerics.Vectors": "4.1.0", + "System.ObjectModel": "4.0.10", + "System.Reflection": "4.0.10", + "System.Reflection.DispatchProxy": "4.0.0", + "System.Reflection.Extensions": "4.0.0", + "System.Reflection.Metadata": "1.0.22", + "System.Reflection.Primitives": "4.0.0", + "System.Reflection.TypeExtensions": "4.0.0", + "System.Resources.ResourceManager": "4.0.0", + "System.Runtime": "4.0.20", + "System.Runtime.Extensions": "4.0.10", + "System.Runtime.Handles": "4.0.0", + "System.Runtime.InteropServices": "4.0.20", + "System.Runtime.Numerics": "4.0.0", + "System.Security.Claims": "4.0.0", + "System.Security.Principal": "4.0.0", + "System.Text.Encoding": "4.0.10", + "System.Text.Encoding.Extensions": "4.0.10", + "System.Text.RegularExpressions": "4.0.10", + "System.Threading": "4.0.10", + "System.Threading.Tasks": "4.0.10", + "System.Threading.Tasks.Dataflow": "4.5.25", + "System.Threading.Tasks.Parallel": "4.0.0", + "System.Threading.Timer": "4.0.0", + "System.Xml.ReaderWriter": "4.0.10", + "System.Xml.XDocument": "4.0.10" + } + }, + "Microsoft.NETCore.Platforms/1.0.0": { + "type": "package" + }, + "Microsoft.NETCore.Portable.Compatibility/1.0.0": { + "type": "package", + "dependencies": { + "Microsoft.NETCore.Runtime": "1.0.0" + }, + "compile": { + "ref/netcore50/System.ComponentModel.DataAnnotations.dll": {}, + "ref/netcore50/System.Core.dll": {}, + "ref/netcore50/System.Net.dll": {}, + "ref/netcore50/System.Numerics.dll": {}, + "ref/netcore50/System.Runtime.Serialization.dll": {}, + "ref/netcore50/System.ServiceModel.Web.dll": {}, + "ref/netcore50/System.ServiceModel.dll": {}, + "ref/netcore50/System.Windows.dll": {}, + "ref/netcore50/System.Xml.Linq.dll": {}, + "ref/netcore50/System.Xml.Serialization.dll": {}, + "ref/netcore50/System.Xml.dll": {}, + "ref/netcore50/System.dll": {}, + "ref/netcore50/mscorlib.dll": {} + }, + "runtime": { + "runtimes/aot/lib/netcore50/System.ComponentModel.DataAnnotations.dll": {}, + "runtimes/aot/lib/netcore50/System.Core.dll": {}, + "runtimes/aot/lib/netcore50/System.Net.dll": {}, + "runtimes/aot/lib/netcore50/System.Numerics.dll": {}, + "runtimes/aot/lib/netcore50/System.Runtime.Serialization.dll": {}, + "runtimes/aot/lib/netcore50/System.ServiceModel.Web.dll": {}, + "runtimes/aot/lib/netcore50/System.ServiceModel.dll": {}, + "runtimes/aot/lib/netcore50/System.Windows.dll": {}, + "runtimes/aot/lib/netcore50/System.Xml.Linq.dll": {}, + "runtimes/aot/lib/netcore50/System.Xml.Serialization.dll": {}, + "runtimes/aot/lib/netcore50/System.Xml.dll": {}, + "runtimes/aot/lib/netcore50/System.dll": {}, + "runtimes/aot/lib/netcore50/mscorlib.dll": {} + } + }, + "Microsoft.NETCore.Runtime/1.0.0": { + "type": "package", + "dependencies": { + "Microsoft.NETCore.Runtime.Native": "1.0.0" + } + }, + "Microsoft.NETCore.Runtime.Native/1.0.0": { + "type": "package", + "dependencies": { + "System.Collections": "[4.0.10]", + "System.Diagnostics.Contracts": "[4.0.0]", + "System.Diagnostics.Debug": "[4.0.10]", + "System.Diagnostics.StackTrace": "[4.0.0]", + "System.Diagnostics.Tools": "[4.0.0]", + "System.Diagnostics.Tracing": "[4.0.20]", + "System.Globalization": "[4.0.10]", + "System.Globalization.Calendars": "[4.0.0]", + "System.IO": "[4.0.10]", + "System.ObjectModel": "[4.0.10]", + "System.Private.Uri": "[4.0.0]", + "System.Reflection": "[4.0.10]", + "System.Reflection.Extensions": "[4.0.0]", + "System.Reflection.Primitives": "[4.0.0]", + "System.Resources.ResourceManager": "[4.0.0]", + "System.Runtime": "[4.0.20]", + "System.Runtime.Extensions": "[4.0.10]", + "System.Runtime.Handles": "[4.0.0]", + "System.Runtime.InteropServices": "[4.0.20]", + "System.Text.Encoding": "[4.0.10]", + "System.Text.Encoding.Extensions": "[4.0.10]", + "System.Threading": "[4.0.10]", + "System.Threading.Tasks": "[4.0.10]", + "System.Threading.Timer": "[4.0.0]" + } + }, + "Microsoft.NETCore.Targets/1.0.0": { + "type": "package", + "dependencies": { + "Microsoft.NETCore.Platforms": "1.0.0", + "Microsoft.NETCore.Targets.UniversalWindowsPlatform": "5.0.0" + } + }, + "Microsoft.NETCore.Targets.UniversalWindowsPlatform/5.0.0": { + "type": "package" + }, + "Microsoft.VisualBasic/10.0.0": { + "type": "package", + "dependencies": { + "System.Collections": "4.0.10", + "System.Diagnostics.Debug": "4.0.10", + "System.Dynamic.Runtime": "4.0.10", + "System.Globalization": "4.0.10", + "System.Linq": "4.0.0", + "System.Linq.Expressions": "4.0.10", + "System.ObjectModel": "4.0.10", + "System.Reflection": "4.0.10", + "System.Reflection.Extensions": "4.0.0", + "System.Reflection.Primitives": "4.0.0", + "System.Reflection.TypeExtensions": "4.0.0", + "System.Resources.ResourceManager": "4.0.0", + "System.Runtime": "4.0.20", + "System.Runtime.Extensions": "4.0.10", + "System.Runtime.InteropServices": "4.0.20", + "System.Threading": "4.0.10" + }, + "compile": { + "ref/netcore50/Microsoft.VisualBasic.dll": {} + }, + "runtime": { + "lib/netcore50/Microsoft.VisualBasic.dll": {} + } + }, + "Microsoft.Win32.Primitives/4.0.0": { + "type": "package", + "dependencies": { + "System.Runtime": "4.0.20", + "System.Runtime.InteropServices": "4.0.20" + }, + "compile": { + "ref/dotnet/Microsoft.Win32.Primitives.dll": {} + }, + "runtime": { + "lib/dotnet/Microsoft.Win32.Primitives.dll": {} + } + }, + "System.AppContext/4.0.0": { + "type": "package", + "dependencies": { + "System.Collections": "4.0.0", + "System.Resources.ResourceManager": "4.0.0", + "System.Runtime": "4.0.20", + "System.Threading": "4.0.0" + }, + "compile": { + "ref/dotnet/System.AppContext.dll": {} + }, + "runtime": { + "lib/netcore50/System.AppContext.dll": {} + } + }, + "System.Collections/4.0.10": { + "type": "package", + "dependencies": { + "System.Diagnostics.Debug": "4.0.0", + "System.Resources.ResourceManager": "4.0.0", + "System.Runtime": "4.0.20", + "System.Runtime.Extensions": "4.0.0", + "System.Threading": "4.0.0" + }, + "compile": { + "ref/dotnet/System.Collections.dll": {} + }, + "runtime": { + "runtimes/win8-aot/lib/netcore50/System.Collections.dll": {} + } + }, + "System.Collections.Concurrent/4.0.10": { + "type": "package", + "dependencies": { + "System.Collections": "4.0.10", + "System.Diagnostics.Debug": "4.0.10", + "System.Diagnostics.Tracing": "4.0.20", + "System.Globalization": "4.0.10", + "System.Resources.ResourceManager": "4.0.0", + "System.Runtime": "4.0.20", + "System.Runtime.Extensions": "4.0.10", + "System.Threading": "4.0.10", + "System.Threading.Tasks": "4.0.10" + }, + "compile": { + "ref/dotnet/System.Collections.Concurrent.dll": {} + }, + "runtime": { + "lib/dotnet/System.Collections.Concurrent.dll": {} + } + }, + "System.Collections.Immutable/1.1.37": { + "type": "package", + "dependencies": { + "System.Collections": "4.0.0", + "System.Diagnostics.Debug": "4.0.0", + "System.Globalization": "4.0.0", + "System.Linq": "4.0.0", + "System.Resources.ResourceManager": "4.0.0", + "System.Runtime": "4.0.0", + "System.Runtime.Extensions": "4.0.0", + "System.Threading": "4.0.0" + }, + "compile": { + "lib/dotnet/System.Collections.Immutable.dll": {} + }, + "runtime": { + "lib/dotnet/System.Collections.Immutable.dll": {} + } + }, + "System.Collections.NonGeneric/4.0.0": { + "type": "package", + "dependencies": { + "System.Diagnostics.Debug": "4.0.10", + "System.Globalization": "4.0.10", + "System.Resources.ResourceManager": "4.0.0", + "System.Runtime": "4.0.20", + "System.Runtime.Extensions": "4.0.10", + "System.Threading": "4.0.10" + }, + "compile": { + "ref/dotnet/System.Collections.NonGeneric.dll": {} + }, + "runtime": { + "lib/dotnet/System.Collections.NonGeneric.dll": {} + } + }, + "System.ComponentModel/4.0.0": { + "type": "package", + "dependencies": { + "System.Runtime": "4.0.20" + }, + "compile": { + "ref/netcore50/System.ComponentModel.dll": {} + }, + "runtime": { + "lib/netcore50/System.ComponentModel.dll": {} + } + }, + "System.ComponentModel.Annotations/4.0.10": { + "type": "package", + "dependencies": { + "System.Collections": "4.0.10", + "System.ComponentModel": "4.0.0", + "System.Globalization": "4.0.10", + "System.Linq": "4.0.0", + "System.Reflection": "4.0.10", + "System.Reflection.Extensions": "4.0.0", + "System.Resources.ResourceManager": "4.0.0", + "System.Runtime": "4.0.20", + "System.Runtime.Extensions": "4.0.10", + "System.Text.RegularExpressions": "4.0.10", + "System.Threading": "4.0.10" + }, + "compile": { + "ref/dotnet/System.ComponentModel.Annotations.dll": {} + }, + "runtime": { + "lib/dotnet/System.ComponentModel.Annotations.dll": {} + } + }, + "System.Diagnostics.Contracts/4.0.0": { + "type": "package", + "compile": { + "ref/netcore50/System.Diagnostics.Contracts.dll": {} + }, + "runtime": { + "runtimes/win8-aot/lib/netcore50/System.Diagnostics.Contracts.dll": {} + } + }, + "System.Diagnostics.Debug/4.0.10": { + "type": "package", + "dependencies": { + "System.Runtime": "4.0.0" + }, + "compile": { + "ref/dotnet/System.Diagnostics.Debug.dll": {} + }, + "runtime": { + "runtimes/win8-aot/lib/netcore50/System.Diagnostics.Debug.dll": {} + } + }, + "System.Diagnostics.StackTrace/4.0.0": { + "type": "package", + "dependencies": { + "System.Runtime": "4.0.20" + }, + "compile": { + "ref/dotnet/System.Diagnostics.StackTrace.dll": {} + }, + "runtime": { + "runtimes/win8-aot/lib/netcore50/System.Diagnostics.StackTrace.dll": {} + } + }, + "System.Diagnostics.Tools/4.0.0": { + "type": "package", + "compile": { + "ref/netcore50/System.Diagnostics.Tools.dll": {} + }, + "runtime": { + "runtimes/win8-aot/lib/netcore50/System.Diagnostics.Tools.dll": {} + } + }, + "System.Diagnostics.Tracing/4.0.20": { + "type": "package", + "dependencies": { + "System.Collections": "4.0.10", + "System.Globalization": "4.0.0", + "System.Reflection": "4.0.10", + "System.Reflection.Extensions": "4.0.0", + "System.Resources.ResourceManager": "4.0.0", + "System.Runtime": "4.0.20", + "System.Runtime.Extensions": "4.0.10", + "System.Runtime.InteropServices": "4.0.0", + "System.Text.Encoding": "4.0.0", + "System.Threading": "4.0.10" + }, + "compile": { + "ref/dotnet/System.Diagnostics.Tracing.dll": {} + }, + "runtime": { + "runtimes/win8-aot/lib/netcore50/System.Diagnostics.Tracing.dll": {} + } + }, + "System.Dynamic.Runtime/4.0.10": { + "type": "package", + "dependencies": { + "System.Collections": "4.0.0", + "System.Diagnostics.Debug": "4.0.0", + "System.Globalization": "4.0.0", + "System.Linq": "4.0.0", + "System.Linq.Expressions": "4.0.10", + "System.ObjectModel": "4.0.0", + "System.Reflection": "4.0.0", + "System.Reflection.TypeExtensions": "4.0.0", + "System.Resources.ResourceManager": "4.0.0", + "System.Runtime": "4.0.20", + "System.Runtime.Extensions": "4.0.0", + "System.Threading": "4.0.0" + }, + "compile": { + "ref/dotnet/System.Dynamic.Runtime.dll": {} + }, + "runtime": { + "runtimes/win8-aot/lib/netcore50/System.Dynamic.Runtime.dll": {} + } + }, + "System.Globalization/4.0.10": { + "type": "package", + "dependencies": { + "System.Runtime": "4.0.0" + }, + "compile": { + "ref/dotnet/System.Globalization.dll": {} + }, + "runtime": { + "runtimes/win8-aot/lib/netcore50/System.Globalization.dll": {} + } + }, + "System.Globalization.Calendars/4.0.0": { + "type": "package", + "dependencies": { + "System.Globalization": "4.0.0", + "System.Runtime": "4.0.0" + }, + "compile": { + "ref/dotnet/System.Globalization.Calendars.dll": {} + }, + "runtime": { + "runtimes/win8-aot/lib/netcore50/System.Globalization.Calendars.dll": {} + } + }, + "System.Globalization.Extensions/4.0.0": { + "type": "package", + "dependencies": { + "System.Globalization": "4.0.10", + "System.Resources.ResourceManager": "4.0.0", + "System.Runtime": "4.0.20", + "System.Runtime.Extensions": "4.0.10", + "System.Runtime.InteropServices": "4.0.20" + }, + "compile": { + "ref/dotnet/System.Globalization.Extensions.dll": {} + }, + "runtime": { + "lib/dotnet/System.Globalization.Extensions.dll": {} + } + }, + "System.IO/4.0.10": { + "type": "package", + "dependencies": { + "System.Globalization": "4.0.0", + "System.Runtime": "4.0.20", + "System.Text.Encoding": "4.0.10", + "System.Text.Encoding.Extensions": "4.0.0", + "System.Threading": "4.0.0", + "System.Threading.Tasks": "4.0.0" + }, + "compile": { + "ref/dotnet/System.IO.dll": {} + }, + "runtime": { + "runtimes/win8-aot/lib/netcore50/System.IO.dll": {} + } + }, + "System.IO.Compression/4.0.0": { + "type": "package", + "dependencies": { + "System.Collections": "4.0.0", + "System.IO": "4.0.0", + "System.IO.Compression.clrcompression-arm": "4.0.0", + "System.Resources.ResourceManager": "4.0.0", + "System.Runtime": "4.0.0", + "System.Runtime.Extensions": "4.0.0", + "System.Runtime.InteropServices": "4.0.0", + "System.Text.Encoding": "4.0.0", + "System.Threading": "4.0.0", + "System.Threading.Tasks": "4.0.0" + }, + "compile": { + "ref/netcore50/System.IO.Compression.dll": {} + }, + "runtime": { + "lib/netcore50/System.IO.Compression.dll": {} + } + }, + "System.IO.Compression.clrcompression-arm/4.0.0": { + "type": "package", + "native": { + "runtimes/win10-arm/native/ClrCompression.dll": {} + } + }, + "System.IO.Compression.ZipFile/4.0.0": { + "type": "package", + "dependencies": { + "System.IO": "4.0.10", + "System.IO.Compression": "4.0.0", + "System.IO.FileSystem": "4.0.0", + "System.IO.FileSystem.Primitives": "4.0.0", + "System.Resources.ResourceManager": "4.0.0", + "System.Runtime": "4.0.20", + "System.Runtime.Extensions": "4.0.10", + "System.Text.Encoding": "4.0.10" + }, + "compile": { + "ref/dotnet/System.IO.Compression.ZipFile.dll": {} + }, + "runtime": { + "lib/dotnet/System.IO.Compression.ZipFile.dll": {} + } + }, + "System.IO.FileSystem/4.0.0": { + "type": "package", + "dependencies": { + "System.Collections": "4.0.10", + "System.Diagnostics.Debug": "4.0.10", + "System.IO": "4.0.10", + "System.IO.FileSystem.Primitives": "4.0.0", + "System.Resources.ResourceManager": "4.0.0", + "System.Runtime": "4.0.20", + "System.Runtime.Extensions": "4.0.10", + "System.Runtime.Handles": "4.0.0", + "System.Runtime.InteropServices": "4.0.20", + "System.Runtime.WindowsRuntime": "4.0.0", + "System.Text.Encoding": "4.0.10", + "System.Text.Encoding.Extensions": "4.0.10", + "System.Threading": "4.0.10", + "System.Threading.Overlapped": "4.0.0", + "System.Threading.Tasks": "4.0.10" + }, + "compile": { + "ref/dotnet/System.IO.FileSystem.dll": {} + }, + "runtime": { + "lib/netcore50/System.IO.FileSystem.dll": {} + } + }, + "System.IO.FileSystem.Primitives/4.0.0": { + "type": "package", + "dependencies": { + "System.Runtime": "4.0.20" + }, + "compile": { + "ref/dotnet/System.IO.FileSystem.Primitives.dll": {} + }, + "runtime": { + "lib/dotnet/System.IO.FileSystem.Primitives.dll": {} + } + }, + "System.IO.UnmanagedMemoryStream/4.0.0": { + "type": "package", + "dependencies": { + "System.IO": "4.0.10", + "System.IO.FileSystem.Primitives": "4.0.0", + "System.Resources.ResourceManager": "4.0.0", + "System.Runtime": "4.0.20", + "System.Runtime.InteropServices": "4.0.20", + "System.Threading": "4.0.10", + "System.Threading.Tasks": "4.0.10" + }, + "compile": { + "ref/dotnet/System.IO.UnmanagedMemoryStream.dll": {} + }, + "runtime": { + "lib/dotnet/System.IO.UnmanagedMemoryStream.dll": {} + } + }, + "System.Linq/4.0.0": { + "type": "package", + "dependencies": { + "System.Collections": "4.0.10", + "System.Diagnostics.Debug": "4.0.10", + "System.Resources.ResourceManager": "4.0.0", + "System.Runtime": "4.0.20", + "System.Runtime.Extensions": "4.0.10" + }, + "compile": { + "ref/netcore50/System.Linq.dll": {} + }, + "runtime": { + "lib/netcore50/System.Linq.dll": {} + } + }, + "System.Linq.Expressions/4.0.10": { + "type": "package", + "dependencies": { + "System.Collections": "4.0.0", + "System.Diagnostics.Debug": "4.0.0", + "System.Globalization": "4.0.0", + "System.IO": "4.0.0", + "System.Linq": "4.0.0", + "System.Reflection": "4.0.0", + "System.Reflection.Extensions": "4.0.0", + "System.Reflection.Primitives": "4.0.0", + "System.Reflection.TypeExtensions": "4.0.0", + "System.Resources.ResourceManager": "4.0.0", + "System.Runtime": "4.0.20", + "System.Runtime.Extensions": "4.0.0", + "System.Threading": "4.0.0" + }, + "compile": { + "ref/dotnet/System.Linq.Expressions.dll": {} + }, + "runtime": { + "runtimes/win8-aot/lib/netcore50/System.Linq.Expressions.dll": {} + } + }, + "System.Linq.Parallel/4.0.0": { + "type": "package", + "dependencies": { + "System.Collections": "4.0.10", + "System.Collections.Concurrent": "4.0.10", + "System.Diagnostics.Debug": "4.0.10", + "System.Diagnostics.Tracing": "4.0.20", + "System.Linq": "4.0.0", + "System.Resources.ResourceManager": "4.0.0", + "System.Runtime": "4.0.20", + "System.Runtime.Extensions": "4.0.10", + "System.Threading": "4.0.10", + "System.Threading.Tasks": "4.0.10" + }, + "compile": { + "ref/netcore50/System.Linq.Parallel.dll": {} + }, + "runtime": { + "lib/netcore50/System.Linq.Parallel.dll": {} + } + }, + "System.Linq.Queryable/4.0.0": { + "type": "package", + "dependencies": { + "System.Collections": "4.0.10", + "System.Linq": "4.0.0", + "System.Linq.Expressions": "4.0.10", + "System.Reflection": "4.0.10", + "System.Reflection.Extensions": "4.0.0", + "System.Resources.ResourceManager": "4.0.0", + "System.Runtime": "4.0.20" + }, + "compile": { + "ref/netcore50/System.Linq.Queryable.dll": {} + }, + "runtime": { + "lib/netcore50/System.Linq.Queryable.dll": {} + } + }, + "System.Net.Http/4.0.0": { + "type": "package", + "dependencies": { + "System.Collections": "4.0.10", + "System.Diagnostics.Debug": "4.0.10", + "System.Globalization": "4.0.10", + "System.IO": "4.0.10", + "System.Net.Primitives": "4.0.0", + "System.Resources.ResourceManager": "4.0.0", + "System.Runtime": "4.0.20", + "System.Runtime.Extensions": "4.0.10", + "System.Runtime.InteropServices": "4.0.20", + "System.Runtime.WindowsRuntime": "4.0.10", + "System.Text.Encoding": "4.0.10", + "System.Text.Encoding.Extensions": "4.0.10", + "System.Threading": "4.0.10", + "System.Threading.Tasks": "4.0.10" + }, + "compile": { + "ref/netcore50/System.Net.Http.dll": {} + }, + "runtime": { + "lib/netcore50/System.Net.Http.dll": {} + } + }, + "System.Net.NetworkInformation/4.0.0": { + "type": "package", + "dependencies": { + "System.Runtime": "4.0.0", + "System.Runtime.InteropServices.WindowsRuntime": "4.0.0", + "System.Threading": "4.0.0" + }, + "compile": { + "ref/netcore50/System.Net.NetworkInformation.dll": {} + }, + "runtime": { + "lib/netcore50/System.Net.NetworkInformation.dll": {} + } + }, + "System.Net.Primitives/4.0.10": { + "type": "package", + "dependencies": { + "System.Private.Networking": "4.0.0", + "System.Runtime": "4.0.20" + }, + "compile": { + "ref/dotnet/System.Net.Primitives.dll": {} + }, + "runtime": { + "lib/netcore50/System.Net.Primitives.dll": {} + } + }, + "System.Numerics.Vectors/4.1.0": { + "type": "package", + "dependencies": { + "System.Globalization": "4.0.10", + "System.Resources.ResourceManager": "4.0.0", + "System.Runtime": "4.0.20", + "System.Runtime.Extensions": "4.0.10" + }, + "compile": { + "ref/dotnet/System.Numerics.Vectors.dll": {} + }, + "runtime": { + "lib/dotnet/System.Numerics.Vectors.dll": {} + } + }, + "System.ObjectModel/4.0.10": { + "type": "package", + "dependencies": { + "System.Collections": "4.0.10", + "System.Diagnostics.Debug": "4.0.10", + "System.Resources.ResourceManager": "4.0.0", + "System.Runtime": "4.0.20", + "System.Threading": "4.0.10" + }, + "compile": { + "ref/dotnet/System.ObjectModel.dll": {} + }, + "runtime": { + "lib/dotnet/System.ObjectModel.dll": {} + } + }, + "System.Private.Networking/4.0.0": { + "type": "package", + "dependencies": { + "Microsoft.Win32.Primitives": "4.0.0", + "System.Collections": "4.0.10", + "System.Collections.NonGeneric": "4.0.0", + "System.Diagnostics.Debug": "4.0.10", + "System.Diagnostics.Tracing": "4.0.20", + "System.Globalization": "4.0.10", + "System.IO": "4.0.10", + "System.IO.FileSystem": "4.0.0", + "System.IO.FileSystem.Primitives": "4.0.0", + "System.Resources.ResourceManager": "4.0.0", + "System.Runtime": "4.0.20", + "System.Runtime.Extensions": "4.0.10", + "System.Runtime.Handles": "4.0.0", + "System.Runtime.InteropServices": "4.0.20", + "System.Threading": "4.0.10", + "System.Threading.Overlapped": "4.0.0", + "System.Threading.Tasks": "4.0.10" + }, + "compile": { + "ref/netcore50/_._": {} + }, + "runtime": { + "lib/netcore50/System.Private.Networking.dll": {} + } + }, + "System.Private.Uri/4.0.0": { + "type": "package", + "compile": { + "ref/netcore50/_._": {} + }, + "runtime": { + "runtimes/win8-aot/lib/netcore50/System.Private.Uri.dll": {} + } + }, + "System.Reflection/4.0.10": { + "type": "package", + "dependencies": { + "System.IO": "4.0.0", + "System.Reflection.Primitives": "4.0.0", + "System.Runtime": "4.0.20" + }, + "compile": { + "ref/dotnet/System.Reflection.dll": {} + }, + "runtime": { + "runtimes/win8-aot/lib/netcore50/System.Reflection.dll": {} + } + }, + "System.Reflection.DispatchProxy/4.0.0": { + "type": "package", + "dependencies": { + "System.Collections": "4.0.10", + "System.Linq": "4.0.0", + "System.Reflection": "4.0.10", + "System.Reflection.Extensions": "4.0.0", + "System.Reflection.Primitives": "4.0.0", + "System.Resources.ResourceManager": "4.0.0", + "System.Runtime": "4.0.20", + "System.Threading": "4.0.10" + }, + "compile": { + "ref/dotnet/System.Reflection.DispatchProxy.dll": {} + }, + "runtime": { + "runtimes/win8-aot/lib/netcore50/System.Reflection.DispatchProxy.dll": {} + } + }, + "System.Reflection.Extensions/4.0.0": { + "type": "package", + "dependencies": { + "System.Diagnostics.Debug": "4.0.10", + "System.Reflection": "4.0.10", + "System.Reflection.Primitives": "4.0.0", + "System.Reflection.TypeExtensions": "4.0.0", + "System.Resources.ResourceManager": "4.0.0", + "System.Runtime": "4.0.20", + "System.Runtime.Extensions": "4.0.10" + }, + "compile": { + "ref/netcore50/System.Reflection.Extensions.dll": {} + }, + "runtime": { + "runtimes/win8-aot/lib/netcore50/System.Reflection.Extensions.dll": {} + } + }, + "System.Reflection.Metadata/1.0.22": { + "type": "package", + "dependencies": { + "System.Collections": "4.0.0", + "System.Collections.Immutable": "1.1.37", + "System.Diagnostics.Debug": "4.0.0", + "System.IO": "4.0.0", + "System.Reflection": "4.0.0", + "System.Reflection.Extensions": "4.0.0", + "System.Reflection.Primitives": "4.0.0", + "System.Resources.ResourceManager": "4.0.0", + "System.Runtime": "4.0.0", + "System.Runtime.Extensions": "4.0.0", + "System.Runtime.InteropServices": "4.0.0", + "System.Text.Encoding": "4.0.0", + "System.Text.Encoding.Extensions": "4.0.0", + "System.Threading": "4.0.0" + }, + "compile": { + "lib/dotnet/System.Reflection.Metadata.dll": {} + }, + "runtime": { + "lib/dotnet/System.Reflection.Metadata.dll": {} + } + }, + "System.Reflection.Primitives/4.0.0": { + "type": "package", + "dependencies": { + "System.Runtime": "4.0.0", + "System.Threading": "4.0.0" + }, + "compile": { + "ref/netcore50/System.Reflection.Primitives.dll": {} + }, + "runtime": { + "runtimes/win8-aot/lib/netcore50/System.Reflection.Primitives.dll": {} + } + }, + "System.Reflection.TypeExtensions/4.0.0": { + "type": "package", + "dependencies": { + "System.Diagnostics.Contracts": "4.0.0", + "System.Diagnostics.Debug": "4.0.10", + "System.Linq": "4.0.0", + "System.Reflection": "4.0.10", + "System.Reflection.Primitives": "4.0.0", + "System.Resources.ResourceManager": "4.0.0", + "System.Runtime": "4.0.20", + "System.Runtime.Extensions": "4.0.10" + }, + "compile": { + "ref/dotnet/System.Reflection.TypeExtensions.dll": {} + }, + "runtime": { + "runtimes/win8-aot/lib/netcore50/System.Reflection.TypeExtensions.dll": {} + } + }, + "System.Resources.ResourceManager/4.0.0": { + "type": "package", + "dependencies": { + "System.Globalization": "4.0.0", + "System.Reflection": "4.0.10", + "System.Runtime": "4.0.20" + }, + "compile": { + "ref/netcore50/System.Resources.ResourceManager.dll": {} + }, + "runtime": { + "runtimes/win8-aot/lib/netcore50/System.Resources.ResourceManager.dll": {} + } + }, + "System.Runtime/4.0.20": { + "type": "package", + "dependencies": { + "System.Private.Uri": "4.0.0" + }, + "compile": { + "ref/dotnet/System.Runtime.dll": {} + }, + "runtime": { + "runtimes/win8-aot/lib/netcore50/System.Runtime.dll": {} + } + }, + "System.Runtime.Extensions/4.0.10": { + "type": "package", + "dependencies": { + "System.Runtime": "4.0.20" + }, + "compile": { + "ref/dotnet/System.Runtime.Extensions.dll": {} + }, + "runtime": { + "runtimes/win8-aot/lib/netcore50/System.Runtime.Extensions.dll": {} + } + }, + "System.Runtime.Handles/4.0.0": { + "type": "package", + "dependencies": { + "System.Runtime": "4.0.0" + }, + "compile": { + "ref/dotnet/System.Runtime.Handles.dll": {} + }, + "runtime": { + "runtimes/win8-aot/lib/netcore50/System.Runtime.Handles.dll": {} + } + }, + "System.Runtime.InteropServices/4.0.20": { + "type": "package", + "dependencies": { + "System.Reflection": "4.0.0", + "System.Reflection.Primitives": "4.0.0", + "System.Runtime": "4.0.0", + "System.Runtime.Handles": "4.0.0" + }, + "compile": { + "ref/dotnet/System.Runtime.InteropServices.dll": {} + }, + "runtime": { + "runtimes/win8-aot/lib/netcore50/System.Runtime.InteropServices.dll": {} + } + }, + "System.Runtime.InteropServices.WindowsRuntime/4.0.0": { + "type": "package", + "compile": { + "ref/netcore50/System.Runtime.InteropServices.WindowsRuntime.dll": {} + }, + "runtime": { + "runtimes/win8-aot/lib/netcore50/System.Runtime.InteropServices.WindowsRuntime.dll": {} + } + }, + "System.Runtime.Numerics/4.0.0": { + "type": "package", + "dependencies": { + "System.Globalization": "4.0.10", + "System.Resources.ResourceManager": "4.0.0", + "System.Runtime": "4.0.20", + "System.Runtime.Extensions": "4.0.10" + }, + "compile": { + "ref/netcore50/System.Runtime.Numerics.dll": {} + }, + "runtime": { + "lib/netcore50/System.Runtime.Numerics.dll": {} + } + }, + "System.Runtime.WindowsRuntime/4.0.10": { + "type": "package", + "dependencies": { + "System.Diagnostics.Debug": "4.0.10", + "System.Globalization": "4.0.0", + "System.IO": "4.0.10", + "System.ObjectModel": "4.0.0", + "System.Resources.ResourceManager": "4.0.0", + "System.Runtime": "4.0.20", + "System.Runtime.Extensions": "4.0.0", + "System.Runtime.InteropServices": "4.0.20", + "System.Threading": "4.0.10", + "System.Threading.Tasks": "4.0.10" + }, + "compile": { + "ref/netcore50/System.Runtime.WindowsRuntime.dll": {} + }, + "runtime": { + "runtimes/win8-aot/lib/netcore50/System.Runtime.WindowsRuntime.dll": {} + } + }, + "System.Security.Claims/4.0.0": { + "type": "package", + "dependencies": { + "System.Collections": "4.0.0", + "System.Diagnostics.Debug": "4.0.0", + "System.Globalization": "4.0.0", + "System.IO": "4.0.0", + "System.Resources.ResourceManager": "4.0.0", + "System.Runtime": "4.0.20", + "System.Runtime.Extensions": "4.0.0", + "System.Security.Principal": "4.0.0" + }, + "compile": { + "ref/dotnet/System.Security.Claims.dll": {} + }, + "runtime": { + "lib/dotnet/System.Security.Claims.dll": {} + } + }, + "System.Security.Principal/4.0.0": { + "type": "package", + "dependencies": { + "System.Runtime": "4.0.0" + }, + "compile": { + "ref/netcore50/System.Security.Principal.dll": {} + }, + "runtime": { + "lib/netcore50/System.Security.Principal.dll": {} + } + }, + "System.Text.Encoding/4.0.10": { + "type": "package", + "dependencies": { + "System.Runtime": "4.0.0" + }, + "compile": { + "ref/dotnet/System.Text.Encoding.dll": {} + }, + "runtime": { + "runtimes/win8-aot/lib/netcore50/System.Text.Encoding.dll": {} + } + }, + "System.Text.Encoding.Extensions/4.0.10": { + "type": "package", + "dependencies": { + "System.Runtime": "4.0.0", + "System.Text.Encoding": "4.0.10" + }, + "compile": { + "ref/dotnet/System.Text.Encoding.Extensions.dll": {} + }, + "runtime": { + "runtimes/win8-aot/lib/netcore50/System.Text.Encoding.Extensions.dll": {} + } + }, + "System.Text.RegularExpressions/4.0.10": { + "type": "package", + "dependencies": { + "System.Collections": "4.0.10", + "System.Globalization": "4.0.10", + "System.Resources.ResourceManager": "4.0.0", + "System.Runtime": "4.0.20", + "System.Runtime.Extensions": "4.0.10", + "System.Threading": "4.0.10" + }, + "compile": { + "ref/dotnet/System.Text.RegularExpressions.dll": {} + }, + "runtime": { + "lib/dotnet/System.Text.RegularExpressions.dll": {} + } + }, + "System.Threading/4.0.10": { + "type": "package", + "dependencies": { + "System.Runtime": "4.0.0", + "System.Threading.Tasks": "4.0.0" + }, + "compile": { + "ref/dotnet/System.Threading.dll": {} + }, + "runtime": { + "runtimes/win8-aot/lib/netcore50/System.Threading.dll": {} + } + }, + "System.Threading.Overlapped/4.0.0": { + "type": "package", + "dependencies": { + "System.Resources.ResourceManager": "4.0.0", + "System.Runtime": "4.0.20", + "System.Runtime.Extensions": "4.0.0", + "System.Runtime.Handles": "4.0.0", + "System.Runtime.InteropServices": "4.0.20", + "System.Threading": "4.0.10" + }, + "compile": { + "ref/dotnet/System.Threading.Overlapped.dll": {} + }, + "runtime": { + "lib/netcore50/System.Threading.Overlapped.dll": {} + } + }, + "System.Threading.Tasks/4.0.10": { + "type": "package", + "dependencies": { + "System.Runtime": "4.0.0" + }, + "compile": { + "ref/dotnet/System.Threading.Tasks.dll": {} + }, + "runtime": { + "runtimes/win8-aot/lib/netcore50/System.Threading.Tasks.dll": {} + } + }, + "System.Threading.Tasks.Dataflow/4.5.25": { + "type": "package", + "dependencies": { + "System.Collections": "4.0.0", + "System.Collections.Concurrent": "4.0.0", + "System.Diagnostics.Debug": "4.0.0", + "System.Diagnostics.Tracing": "4.0.0", + "System.Dynamic.Runtime": "4.0.0", + "System.Linq": "4.0.0", + "System.Resources.ResourceManager": "4.0.0", + "System.Runtime": "4.0.0", + "System.Runtime.Extensions": "4.0.0", + "System.Threading": "4.0.0", + "System.Threading.Tasks": "4.0.0" + }, + "compile": { + "lib/dotnet/System.Threading.Tasks.Dataflow.dll": {} + }, + "runtime": { + "lib/dotnet/System.Threading.Tasks.Dataflow.dll": {} + } + }, + "System.Threading.Tasks.Parallel/4.0.0": { + "type": "package", + "dependencies": { + "System.Collections.Concurrent": "4.0.10", + "System.Diagnostics.Debug": "4.0.10", + "System.Diagnostics.Tracing": "4.0.20", + "System.Resources.ResourceManager": "4.0.0", + "System.Runtime": "4.0.20", + "System.Runtime.Extensions": "4.0.10", + "System.Threading": "4.0.10", + "System.Threading.Tasks": "4.0.10" + }, + "compile": { + "ref/netcore50/System.Threading.Tasks.Parallel.dll": {} + }, + "runtime": { + "lib/netcore50/System.Threading.Tasks.Parallel.dll": {} + } + }, + "System.Threading.Timer/4.0.0": { + "type": "package", + "compile": { + "ref/netcore50/System.Threading.Timer.dll": {} + }, + "runtime": { + "runtimes/win8-aot/lib/netcore50/System.Threading.Timer.dll": {} + } + }, + "System.Xml.ReaderWriter/4.0.10": { + "type": "package", + "dependencies": { + "System.Collections": "4.0.10", + "System.Diagnostics.Debug": "4.0.10", + "System.Globalization": "4.0.10", + "System.IO": "4.0.10", + "System.IO.FileSystem": "4.0.0", + "System.IO.FileSystem.Primitives": "4.0.0", + "System.Resources.ResourceManager": "4.0.0", + "System.Runtime": "4.0.20", + "System.Runtime.Extensions": "4.0.10", + "System.Runtime.InteropServices": "4.0.20", + "System.Text.Encoding": "4.0.10", + "System.Text.Encoding.Extensions": "4.0.10", + "System.Text.RegularExpressions": "4.0.10", + "System.Threading.Tasks": "4.0.10" + }, + "compile": { + "ref/dotnet/System.Xml.ReaderWriter.dll": {} + }, + "runtime": { + "lib/dotnet/System.Xml.ReaderWriter.dll": {} + } + }, + "System.Xml.XDocument/4.0.10": { + "type": "package", + "dependencies": { + "System.Collections": "4.0.10", + "System.Diagnostics.Debug": "4.0.10", + "System.Globalization": "4.0.10", + "System.IO": "4.0.10", + "System.Reflection": "4.0.10", + "System.Resources.ResourceManager": "4.0.0", + "System.Runtime": "4.0.20", + "System.Runtime.Extensions": "4.0.10", + "System.Text.Encoding": "4.0.10", + "System.Threading": "4.0.10", + "System.Xml.ReaderWriter": "4.0.10" + }, + "compile": { + "ref/dotnet/System.Xml.XDocument.dll": {} + }, + "runtime": { + "lib/dotnet/System.Xml.XDocument.dll": {} + } + } + }, + "UAP,Version=v10.0/win10-x64": { + "Microsoft.CSharp/4.0.0": { + "type": "package", + "dependencies": { + "System.Collections": "4.0.10", + "System.Diagnostics.Debug": "4.0.10", + "System.Dynamic.Runtime": "4.0.0", + "System.Globalization": "4.0.10", + "System.Linq": "4.0.0", + "System.Linq.Expressions": "4.0.0", + "System.ObjectModel": "4.0.10", + "System.Reflection": "4.0.10", + "System.Reflection.Extensions": "4.0.0", + "System.Reflection.Primitives": "4.0.0", + "System.Reflection.TypeExtensions": "4.0.0", + "System.Resources.ResourceManager": "4.0.0", + "System.Runtime": "4.0.20", + "System.Runtime.Extensions": "4.0.10", + "System.Runtime.InteropServices": "4.0.20", + "System.Threading": "4.0.10" + }, + "compile": { + "ref/netcore50/Microsoft.CSharp.dll": {} + }, + "runtime": { + "lib/netcore50/Microsoft.CSharp.dll": {} + } + }, + "Microsoft.NETCore/5.0.0": { + "type": "package", + "dependencies": { + "Microsoft.CSharp": "4.0.0", + "Microsoft.NETCore.Targets": "1.0.0", + "Microsoft.VisualBasic": "10.0.0", + "System.AppContext": "4.0.0", + "System.Collections": "4.0.10", + "System.Collections.Concurrent": "4.0.10", + "System.Collections.Immutable": "1.1.37", + "System.ComponentModel": "4.0.0", + "System.ComponentModel.Annotations": "4.0.10", + "System.Diagnostics.Debug": "4.0.10", + "System.Diagnostics.Tools": "4.0.0", + "System.Diagnostics.Tracing": "4.0.20", + "System.Dynamic.Runtime": "4.0.10", + "System.Globalization": "4.0.10", + "System.Globalization.Calendars": "4.0.0", + "System.Globalization.Extensions": "4.0.0", + "System.IO": "4.0.10", + "System.IO.Compression": "4.0.0", + "System.IO.Compression.ZipFile": "4.0.0", + "System.IO.FileSystem": "4.0.0", + "System.IO.FileSystem.Primitives": "4.0.0", + "System.IO.UnmanagedMemoryStream": "4.0.0", + "System.Linq": "4.0.0", + "System.Linq.Expressions": "4.0.10", + "System.Linq.Parallel": "4.0.0", + "System.Linq.Queryable": "4.0.0", + "System.Net.Http": "4.0.0", + "System.Net.NetworkInformation": "4.0.0", + "System.Net.Primitives": "4.0.10", + "System.Numerics.Vectors": "4.1.0", + "System.ObjectModel": "4.0.10", + "System.Reflection": "4.0.10", + "System.Reflection.DispatchProxy": "4.0.0", + "System.Reflection.Extensions": "4.0.0", + "System.Reflection.Metadata": "1.0.22", + "System.Reflection.Primitives": "4.0.0", + "System.Reflection.TypeExtensions": "4.0.0", + "System.Resources.ResourceManager": "4.0.0", + "System.Runtime": "4.0.20", + "System.Runtime.Extensions": "4.0.10", + "System.Runtime.Handles": "4.0.0", + "System.Runtime.InteropServices": "4.0.20", + "System.Runtime.Numerics": "4.0.0", + "System.Security.Claims": "4.0.0", + "System.Security.Principal": "4.0.0", + "System.Text.Encoding": "4.0.10", + "System.Text.Encoding.Extensions": "4.0.10", + "System.Text.RegularExpressions": "4.0.10", + "System.Threading": "4.0.10", + "System.Threading.Tasks": "4.0.10", + "System.Threading.Tasks.Dataflow": "4.5.25", + "System.Threading.Tasks.Parallel": "4.0.0", + "System.Threading.Timer": "4.0.0", + "System.Xml.ReaderWriter": "4.0.10", + "System.Xml.XDocument": "4.0.10" + } + }, + "Microsoft.NETCore.Platforms/1.0.0": { + "type": "package" + }, + "Microsoft.NETCore.Portable.Compatibility/1.0.0": { + "type": "package", + "dependencies": { + "Microsoft.NETCore.Runtime": "1.0.0" + }, + "compile": { + "ref/netcore50/System.ComponentModel.DataAnnotations.dll": {}, + "ref/netcore50/System.Core.dll": {}, + "ref/netcore50/System.Net.dll": {}, + "ref/netcore50/System.Numerics.dll": {}, + "ref/netcore50/System.Runtime.Serialization.dll": {}, + "ref/netcore50/System.ServiceModel.Web.dll": {}, + "ref/netcore50/System.ServiceModel.dll": {}, + "ref/netcore50/System.Windows.dll": {}, + "ref/netcore50/System.Xml.Linq.dll": {}, + "ref/netcore50/System.Xml.Serialization.dll": {}, + "ref/netcore50/System.Xml.dll": {}, + "ref/netcore50/System.dll": {}, + "ref/netcore50/mscorlib.dll": {} + }, + "runtime": { + "lib/netcore50/System.ComponentModel.DataAnnotations.dll": {}, + "lib/netcore50/System.Core.dll": {}, + "lib/netcore50/System.Net.dll": {}, + "lib/netcore50/System.Numerics.dll": {}, + "lib/netcore50/System.Runtime.Serialization.dll": {}, + "lib/netcore50/System.ServiceModel.Web.dll": {}, + "lib/netcore50/System.ServiceModel.dll": {}, + "lib/netcore50/System.Windows.dll": {}, + "lib/netcore50/System.Xml.Linq.dll": {}, + "lib/netcore50/System.Xml.Serialization.dll": {}, + "lib/netcore50/System.Xml.dll": {}, + "lib/netcore50/System.dll": {} + } + }, + "Microsoft.NETCore.Runtime/1.0.0": { + "type": "package", + "dependencies": { + "Microsoft.NETCore.Runtime.CoreCLR-x64": "1.0.0", + "Microsoft.NETCore.Windows.ApiSets-x64": "1.0.0" + } + }, + "Microsoft.NETCore.Runtime.CoreCLR-x64/1.0.0": { + "type": "package", + "dependencies": { + "System.Collections": "[4.0.10]", + "System.Diagnostics.Contracts": "[4.0.0]", + "System.Diagnostics.Debug": "[4.0.10]", + "System.Diagnostics.StackTrace": "[4.0.0]", + "System.Diagnostics.Tools": "[4.0.0]", + "System.Diagnostics.Tracing": "[4.0.20]", + "System.Globalization": "[4.0.10]", + "System.Globalization.Calendars": "[4.0.0]", + "System.IO": "[4.0.10]", + "System.ObjectModel": "[4.0.10]", + "System.Private.Uri": "[4.0.0]", + "System.Reflection": "[4.0.10]", + "System.Reflection.Extensions": "[4.0.0]", + "System.Reflection.Primitives": "[4.0.0]", + "System.Resources.ResourceManager": "[4.0.0]", + "System.Runtime": "[4.0.20]", + "System.Runtime.Extensions": "[4.0.10]", + "System.Runtime.Handles": "[4.0.0]", + "System.Runtime.InteropServices": "[4.0.20]", + "System.Text.Encoding": "[4.0.10]", + "System.Text.Encoding.Extensions": "[4.0.10]", + "System.Threading": "[4.0.10]", + "System.Threading.Tasks": "[4.0.10]", + "System.Threading.Timer": "[4.0.0]" + }, + "compile": { + "ref/dotnet/_._": {} + }, + "runtime": { + "runtimes/win7-x64/lib/dotnet/mscorlib.ni.dll": {} + }, + "native": { + "runtimes/win7-x64/native/clretwrc.dll": {}, + "runtimes/win7-x64/native/coreclr.dll": {}, + "runtimes/win7-x64/native/dbgshim.dll": {}, + "runtimes/win7-x64/native/mscordaccore.dll": {}, + "runtimes/win7-x64/native/mscordbi.dll": {}, + "runtimes/win7-x64/native/mscorrc.debug.dll": {}, + "runtimes/win7-x64/native/mscorrc.dll": {} + } + }, + "Microsoft.NETCore.Targets/1.0.0": { + "type": "package", + "dependencies": { + "Microsoft.NETCore.Platforms": "1.0.0", + "Microsoft.NETCore.Targets.UniversalWindowsPlatform": "5.0.0" + } + }, + "Microsoft.NETCore.Targets.UniversalWindowsPlatform/5.0.0": { + "type": "package" + }, + "Microsoft.NETCore.Windows.ApiSets-x64/1.0.0": { + "type": "package", + "native": { + "runtimes/win10-x64/native/_._": {} + } + }, + "Microsoft.VisualBasic/10.0.0": { + "type": "package", + "dependencies": { + "System.Collections": "4.0.10", + "System.Diagnostics.Debug": "4.0.10", + "System.Dynamic.Runtime": "4.0.10", + "System.Globalization": "4.0.10", + "System.Linq": "4.0.0", + "System.Linq.Expressions": "4.0.10", + "System.ObjectModel": "4.0.10", + "System.Reflection": "4.0.10", + "System.Reflection.Extensions": "4.0.0", + "System.Reflection.Primitives": "4.0.0", + "System.Reflection.TypeExtensions": "4.0.0", + "System.Resources.ResourceManager": "4.0.0", + "System.Runtime": "4.0.20", + "System.Runtime.Extensions": "4.0.10", + "System.Runtime.InteropServices": "4.0.20", + "System.Threading": "4.0.10" + }, + "compile": { + "ref/netcore50/Microsoft.VisualBasic.dll": {} + }, + "runtime": { + "lib/netcore50/Microsoft.VisualBasic.dll": {} + } + }, + "Microsoft.Win32.Primitives/4.0.0": { + "type": "package", + "dependencies": { + "System.Runtime": "4.0.20", + "System.Runtime.InteropServices": "4.0.20" + }, + "compile": { + "ref/dotnet/Microsoft.Win32.Primitives.dll": {} + }, + "runtime": { + "lib/dotnet/Microsoft.Win32.Primitives.dll": {} + } + }, + "System.AppContext/4.0.0": { + "type": "package", + "dependencies": { + "System.Collections": "4.0.0", + "System.Resources.ResourceManager": "4.0.0", + "System.Runtime": "4.0.20", + "System.Threading": "4.0.0" + }, + "compile": { + "ref/dotnet/System.AppContext.dll": {} + }, + "runtime": { + "lib/netcore50/System.AppContext.dll": {} + } + }, + "System.Collections/4.0.10": { + "type": "package", + "dependencies": { + "System.Diagnostics.Debug": "4.0.0", + "System.Resources.ResourceManager": "4.0.0", + "System.Runtime": "4.0.20", + "System.Runtime.Extensions": "4.0.0", + "System.Threading": "4.0.0" + }, + "compile": { + "ref/dotnet/System.Collections.dll": {} + }, + "runtime": { + "lib/netcore50/System.Collections.dll": {} + } + }, + "System.Collections.Concurrent/4.0.10": { + "type": "package", + "dependencies": { + "System.Collections": "4.0.10", + "System.Diagnostics.Debug": "4.0.10", + "System.Diagnostics.Tracing": "4.0.20", + "System.Globalization": "4.0.10", + "System.Resources.ResourceManager": "4.0.0", + "System.Runtime": "4.0.20", + "System.Runtime.Extensions": "4.0.10", + "System.Threading": "4.0.10", + "System.Threading.Tasks": "4.0.10" + }, + "compile": { + "ref/dotnet/System.Collections.Concurrent.dll": {} + }, + "runtime": { + "lib/dotnet/System.Collections.Concurrent.dll": {} + } + }, + "System.Collections.Immutable/1.1.37": { + "type": "package", + "dependencies": { + "System.Collections": "4.0.0", + "System.Diagnostics.Debug": "4.0.0", + "System.Globalization": "4.0.0", + "System.Linq": "4.0.0", + "System.Resources.ResourceManager": "4.0.0", + "System.Runtime": "4.0.0", + "System.Runtime.Extensions": "4.0.0", + "System.Threading": "4.0.0" + }, + "compile": { + "lib/dotnet/System.Collections.Immutable.dll": {} + }, + "runtime": { + "lib/dotnet/System.Collections.Immutable.dll": {} + } + }, + "System.Collections.NonGeneric/4.0.0": { + "type": "package", + "dependencies": { + "System.Diagnostics.Debug": "4.0.10", + "System.Globalization": "4.0.10", + "System.Resources.ResourceManager": "4.0.0", + "System.Runtime": "4.0.20", + "System.Runtime.Extensions": "4.0.10", + "System.Threading": "4.0.10" + }, + "compile": { + "ref/dotnet/System.Collections.NonGeneric.dll": {} + }, + "runtime": { + "lib/dotnet/System.Collections.NonGeneric.dll": {} + } + }, + "System.ComponentModel/4.0.0": { + "type": "package", + "dependencies": { + "System.Runtime": "4.0.20" + }, + "compile": { + "ref/netcore50/System.ComponentModel.dll": {} + }, + "runtime": { + "lib/netcore50/System.ComponentModel.dll": {} + } + }, + "System.ComponentModel.Annotations/4.0.10": { + "type": "package", + "dependencies": { + "System.Collections": "4.0.10", + "System.ComponentModel": "4.0.0", + "System.Globalization": "4.0.10", + "System.Linq": "4.0.0", + "System.Reflection": "4.0.10", + "System.Reflection.Extensions": "4.0.0", + "System.Resources.ResourceManager": "4.0.0", + "System.Runtime": "4.0.20", + "System.Runtime.Extensions": "4.0.10", + "System.Text.RegularExpressions": "4.0.10", + "System.Threading": "4.0.10" + }, + "compile": { + "ref/dotnet/System.ComponentModel.Annotations.dll": {} + }, + "runtime": { + "lib/dotnet/System.ComponentModel.Annotations.dll": {} + } + }, + "System.Diagnostics.Contracts/4.0.0": { + "type": "package", + "compile": { + "ref/netcore50/System.Diagnostics.Contracts.dll": {} + }, + "runtime": { + "lib/netcore50/System.Diagnostics.Contracts.dll": {} + } + }, + "System.Diagnostics.Debug/4.0.10": { + "type": "package", + "dependencies": { + "System.Runtime": "4.0.0" + }, + "compile": { + "ref/dotnet/System.Diagnostics.Debug.dll": {} + }, + "runtime": { + "lib/netcore50/System.Diagnostics.Debug.dll": {} + } + }, + "System.Diagnostics.StackTrace/4.0.0": { + "type": "package", + "dependencies": { + "System.Runtime": "4.0.20" + }, + "compile": { + "ref/dotnet/System.Diagnostics.StackTrace.dll": {} + }, + "runtime": { + "lib/netcore50/System.Diagnostics.StackTrace.dll": {} + } + }, + "System.Diagnostics.Tools/4.0.0": { + "type": "package", + "compile": { + "ref/netcore50/System.Diagnostics.Tools.dll": {} + }, + "runtime": { + "lib/netcore50/System.Diagnostics.Tools.dll": {} + } + }, + "System.Diagnostics.Tracing/4.0.20": { + "type": "package", + "dependencies": { + "System.Collections": "4.0.10", + "System.Globalization": "4.0.0", + "System.Reflection": "4.0.10", + "System.Reflection.Extensions": "4.0.0", + "System.Resources.ResourceManager": "4.0.0", + "System.Runtime": "4.0.20", + "System.Runtime.Extensions": "4.0.10", + "System.Runtime.InteropServices": "4.0.0", + "System.Text.Encoding": "4.0.0", + "System.Threading": "4.0.10" + }, + "compile": { + "ref/dotnet/System.Diagnostics.Tracing.dll": {} + }, + "runtime": { + "lib/netcore50/System.Diagnostics.Tracing.dll": {} + } + }, + "System.Dynamic.Runtime/4.0.10": { + "type": "package", + "dependencies": { + "System.Collections": "4.0.0", + "System.Diagnostics.Debug": "4.0.0", + "System.Globalization": "4.0.0", + "System.Linq": "4.0.0", + "System.Linq.Expressions": "4.0.10", + "System.ObjectModel": "4.0.0", + "System.Reflection": "4.0.0", + "System.Reflection.Emit.ILGeneration": "4.0.0", + "System.Reflection.Emit.Lightweight": "4.0.0", + "System.Reflection.TypeExtensions": "4.0.0", + "System.Resources.ResourceManager": "4.0.0", + "System.Runtime": "4.0.20", + "System.Runtime.Extensions": "4.0.0", + "System.Threading": "4.0.0" + }, + "compile": { + "ref/dotnet/System.Dynamic.Runtime.dll": {} + }, + "runtime": { + "lib/netcore50/System.Dynamic.Runtime.dll": {} + } + }, + "System.Globalization/4.0.10": { + "type": "package", + "dependencies": { + "System.Runtime": "4.0.0" + }, + "compile": { + "ref/dotnet/System.Globalization.dll": {} + }, + "runtime": { + "lib/netcore50/System.Globalization.dll": {} + } + }, + "System.Globalization.Calendars/4.0.0": { + "type": "package", + "dependencies": { + "System.Globalization": "4.0.0", + "System.Runtime": "4.0.0" + }, + "compile": { + "ref/dotnet/System.Globalization.Calendars.dll": {} + }, + "runtime": { + "lib/netcore50/System.Globalization.Calendars.dll": {} + } + }, + "System.Globalization.Extensions/4.0.0": { + "type": "package", + "dependencies": { + "System.Globalization": "4.0.10", + "System.Resources.ResourceManager": "4.0.0", + "System.Runtime": "4.0.20", + "System.Runtime.Extensions": "4.0.10", + "System.Runtime.InteropServices": "4.0.20" + }, + "compile": { + "ref/dotnet/System.Globalization.Extensions.dll": {} + }, + "runtime": { + "lib/dotnet/System.Globalization.Extensions.dll": {} + } + }, + "System.IO/4.0.10": { + "type": "package", + "dependencies": { + "System.Globalization": "4.0.0", + "System.Runtime": "4.0.20", + "System.Text.Encoding": "4.0.10", + "System.Text.Encoding.Extensions": "4.0.0", + "System.Threading": "4.0.0", + "System.Threading.Tasks": "4.0.0" + }, + "compile": { + "ref/dotnet/System.IO.dll": {} + }, + "runtime": { + "lib/netcore50/System.IO.dll": {} + } + }, + "System.IO.Compression/4.0.0": { + "type": "package", + "dependencies": { + "System.Collections": "4.0.0", + "System.IO": "4.0.0", + "System.IO.Compression.clrcompression-x64": "4.0.0", + "System.Resources.ResourceManager": "4.0.0", + "System.Runtime": "4.0.0", + "System.Runtime.Extensions": "4.0.0", + "System.Runtime.InteropServices": "4.0.0", + "System.Text.Encoding": "4.0.0", + "System.Threading": "4.0.0", + "System.Threading.Tasks": "4.0.0" + }, + "compile": { + "ref/netcore50/System.IO.Compression.dll": {} + }, + "runtime": { + "lib/netcore50/System.IO.Compression.dll": {} + } + }, + "System.IO.Compression.clrcompression-x64/4.0.0": { + "type": "package", + "native": { + "runtimes/win10-x64/native/ClrCompression.dll": {} + } + }, + "System.IO.Compression.ZipFile/4.0.0": { + "type": "package", + "dependencies": { + "System.IO": "4.0.10", + "System.IO.Compression": "4.0.0", + "System.IO.FileSystem": "4.0.0", + "System.IO.FileSystem.Primitives": "4.0.0", + "System.Resources.ResourceManager": "4.0.0", + "System.Runtime": "4.0.20", + "System.Runtime.Extensions": "4.0.10", + "System.Text.Encoding": "4.0.10" + }, + "compile": { + "ref/dotnet/System.IO.Compression.ZipFile.dll": {} + }, + "runtime": { + "lib/dotnet/System.IO.Compression.ZipFile.dll": {} + } + }, + "System.IO.FileSystem/4.0.0": { + "type": "package", + "dependencies": { + "System.Collections": "4.0.10", + "System.Diagnostics.Debug": "4.0.10", + "System.IO": "4.0.10", + "System.IO.FileSystem.Primitives": "4.0.0", + "System.Resources.ResourceManager": "4.0.0", + "System.Runtime": "4.0.20", + "System.Runtime.Extensions": "4.0.10", + "System.Runtime.Handles": "4.0.0", + "System.Runtime.InteropServices": "4.0.20", + "System.Runtime.WindowsRuntime": "4.0.0", + "System.Text.Encoding": "4.0.10", + "System.Text.Encoding.Extensions": "4.0.10", + "System.Threading": "4.0.10", + "System.Threading.Overlapped": "4.0.0", + "System.Threading.Tasks": "4.0.10" + }, + "compile": { + "ref/dotnet/System.IO.FileSystem.dll": {} + }, + "runtime": { + "lib/netcore50/System.IO.FileSystem.dll": {} + } + }, + "System.IO.FileSystem.Primitives/4.0.0": { + "type": "package", + "dependencies": { + "System.Runtime": "4.0.20" + }, + "compile": { + "ref/dotnet/System.IO.FileSystem.Primitives.dll": {} + }, + "runtime": { + "lib/dotnet/System.IO.FileSystem.Primitives.dll": {} + } + }, + "System.IO.UnmanagedMemoryStream/4.0.0": { + "type": "package", + "dependencies": { + "System.IO": "4.0.10", + "System.IO.FileSystem.Primitives": "4.0.0", + "System.Resources.ResourceManager": "4.0.0", + "System.Runtime": "4.0.20", + "System.Runtime.InteropServices": "4.0.20", + "System.Threading": "4.0.10", + "System.Threading.Tasks": "4.0.10" + }, + "compile": { + "ref/dotnet/System.IO.UnmanagedMemoryStream.dll": {} + }, + "runtime": { + "lib/dotnet/System.IO.UnmanagedMemoryStream.dll": {} + } + }, + "System.Linq/4.0.0": { + "type": "package", + "dependencies": { + "System.Collections": "4.0.10", + "System.Diagnostics.Debug": "4.0.10", + "System.Resources.ResourceManager": "4.0.0", + "System.Runtime": "4.0.20", + "System.Runtime.Extensions": "4.0.10" + }, + "compile": { + "ref/netcore50/System.Linq.dll": {} + }, + "runtime": { + "lib/netcore50/System.Linq.dll": {} + } + }, + "System.Linq.Expressions/4.0.10": { + "type": "package", + "dependencies": { + "System.Collections": "4.0.0", + "System.Diagnostics.Debug": "4.0.0", + "System.Globalization": "4.0.0", + "System.IO": "4.0.0", + "System.Linq": "4.0.0", + "System.Reflection": "4.0.0", + "System.Reflection.Emit.ILGeneration": "4.0.0", + "System.Reflection.Emit.Lightweight": "4.0.0", + "System.Reflection.Extensions": "4.0.0", + "System.Reflection.Primitives": "4.0.0", + "System.Reflection.TypeExtensions": "4.0.0", + "System.Resources.ResourceManager": "4.0.0", + "System.Runtime": "4.0.20", + "System.Runtime.Extensions": "4.0.0", + "System.Threading": "4.0.0" + }, + "compile": { + "ref/dotnet/System.Linq.Expressions.dll": {} + }, + "runtime": { + "lib/netcore50/System.Linq.Expressions.dll": {} + } + }, + "System.Linq.Parallel/4.0.0": { + "type": "package", + "dependencies": { + "System.Collections": "4.0.10", + "System.Collections.Concurrent": "4.0.10", + "System.Diagnostics.Debug": "4.0.10", + "System.Diagnostics.Tracing": "4.0.20", + "System.Linq": "4.0.0", + "System.Resources.ResourceManager": "4.0.0", + "System.Runtime": "4.0.20", + "System.Runtime.Extensions": "4.0.10", + "System.Threading": "4.0.10", + "System.Threading.Tasks": "4.0.10" + }, + "compile": { + "ref/netcore50/System.Linq.Parallel.dll": {} + }, + "runtime": { + "lib/netcore50/System.Linq.Parallel.dll": {} + } + }, + "System.Linq.Queryable/4.0.0": { + "type": "package", + "dependencies": { + "System.Collections": "4.0.10", + "System.Linq": "4.0.0", + "System.Linq.Expressions": "4.0.10", + "System.Reflection": "4.0.10", + "System.Reflection.Extensions": "4.0.0", + "System.Resources.ResourceManager": "4.0.0", + "System.Runtime": "4.0.20" + }, + "compile": { + "ref/netcore50/System.Linq.Queryable.dll": {} + }, + "runtime": { + "lib/netcore50/System.Linq.Queryable.dll": {} + } + }, + "System.Net.Http/4.0.0": { + "type": "package", + "dependencies": { + "System.Collections": "4.0.10", + "System.Diagnostics.Debug": "4.0.10", + "System.Globalization": "4.0.10", + "System.IO": "4.0.10", + "System.Net.Primitives": "4.0.0", + "System.Resources.ResourceManager": "4.0.0", + "System.Runtime": "4.0.20", + "System.Runtime.Extensions": "4.0.10", + "System.Runtime.InteropServices": "4.0.20", + "System.Runtime.WindowsRuntime": "4.0.10", + "System.Text.Encoding": "4.0.10", + "System.Text.Encoding.Extensions": "4.0.10", + "System.Threading": "4.0.10", + "System.Threading.Tasks": "4.0.10" + }, + "compile": { + "ref/netcore50/System.Net.Http.dll": {} + }, + "runtime": { + "lib/netcore50/System.Net.Http.dll": {} + } + }, + "System.Net.NetworkInformation/4.0.0": { + "type": "package", + "dependencies": { + "System.Runtime": "4.0.0", + "System.Runtime.InteropServices.WindowsRuntime": "4.0.0", + "System.Threading": "4.0.0" + }, + "compile": { + "ref/netcore50/System.Net.NetworkInformation.dll": {} + }, + "runtime": { + "lib/netcore50/System.Net.NetworkInformation.dll": {} + } + }, + "System.Net.Primitives/4.0.10": { + "type": "package", + "dependencies": { + "System.Private.Networking": "4.0.0", + "System.Runtime": "4.0.20" + }, + "compile": { + "ref/dotnet/System.Net.Primitives.dll": {} + }, + "runtime": { + "lib/netcore50/System.Net.Primitives.dll": {} + } + }, + "System.Numerics.Vectors/4.1.0": { + "type": "package", + "dependencies": { + "System.Globalization": "4.0.10", + "System.Resources.ResourceManager": "4.0.0", + "System.Runtime": "4.0.20", + "System.Runtime.Extensions": "4.0.10" + }, + "compile": { + "ref/dotnet/System.Numerics.Vectors.dll": {} + }, + "runtime": { + "lib/dotnet/System.Numerics.Vectors.dll": {} + } + }, + "System.ObjectModel/4.0.10": { + "type": "package", + "dependencies": { + "System.Collections": "4.0.10", + "System.Diagnostics.Debug": "4.0.10", + "System.Resources.ResourceManager": "4.0.0", + "System.Runtime": "4.0.20", + "System.Threading": "4.0.10" + }, + "compile": { + "ref/dotnet/System.ObjectModel.dll": {} + }, + "runtime": { + "lib/dotnet/System.ObjectModel.dll": {} + } + }, + "System.Private.Networking/4.0.0": { + "type": "package", + "dependencies": { + "Microsoft.Win32.Primitives": "4.0.0", + "System.Collections": "4.0.10", + "System.Collections.NonGeneric": "4.0.0", + "System.Diagnostics.Debug": "4.0.10", + "System.Diagnostics.Tracing": "4.0.20", + "System.Globalization": "4.0.10", + "System.IO": "4.0.10", + "System.IO.FileSystem": "4.0.0", + "System.IO.FileSystem.Primitives": "4.0.0", + "System.Resources.ResourceManager": "4.0.0", + "System.Runtime": "4.0.20", + "System.Runtime.Extensions": "4.0.10", + "System.Runtime.Handles": "4.0.0", + "System.Runtime.InteropServices": "4.0.20", + "System.Threading": "4.0.10", + "System.Threading.Overlapped": "4.0.0", + "System.Threading.Tasks": "4.0.10" + }, + "compile": { + "ref/netcore50/_._": {} + }, + "runtime": { + "lib/netcore50/System.Private.Networking.dll": {} + } + }, + "System.Private.Uri/4.0.0": { + "type": "package", + "compile": { + "ref/netcore50/_._": {} + }, + "runtime": { + "lib/netcore50/System.Private.Uri.dll": {} + } + }, + "System.Reflection/4.0.10": { + "type": "package", + "dependencies": { + "System.IO": "4.0.0", + "System.Reflection.Primitives": "4.0.0", + "System.Runtime": "4.0.20" + }, + "compile": { + "ref/dotnet/System.Reflection.dll": {} + }, + "runtime": { + "lib/netcore50/System.Reflection.dll": {} + } + }, + "System.Reflection.DispatchProxy/4.0.0": { + "type": "package", + "dependencies": { + "System.Collections": "4.0.10", + "System.Linq": "4.0.0", + "System.Reflection": "4.0.10", + "System.Reflection.Emit": "4.0.0", + "System.Reflection.Emit.ILGeneration": "4.0.0", + "System.Reflection.Extensions": "4.0.0", + "System.Reflection.Primitives": "4.0.0", + "System.Resources.ResourceManager": "4.0.0", + "System.Runtime": "4.0.20", + "System.Threading": "4.0.10" + }, + "compile": { + "ref/dotnet/System.Reflection.DispatchProxy.dll": {} + }, + "runtime": { + "lib/netcore50/System.Reflection.DispatchProxy.dll": {} + } + }, + "System.Reflection.Emit/4.0.0": { + "type": "package", + "dependencies": { + "System.IO": "4.0.0", + "System.Reflection": "4.0.0", + "System.Reflection.Emit.ILGeneration": "4.0.0", + "System.Reflection.Primitives": "4.0.0", + "System.Runtime": "4.0.0" + }, + "compile": { + "ref/dotnet/System.Reflection.Emit.dll": {} + }, + "runtime": { + "lib/netcore50/System.Reflection.Emit.dll": {} + } + }, + "System.Reflection.Emit.ILGeneration/4.0.0": { + "type": "package", + "dependencies": { + "System.Reflection": "4.0.0", + "System.Reflection.Primitives": "4.0.0", + "System.Runtime": "4.0.0" + }, + "compile": { + "ref/dotnet/System.Reflection.Emit.ILGeneration.dll": {} + }, + "runtime": { + "lib/netcore50/System.Reflection.Emit.ILGeneration.dll": {} + } + }, + "System.Reflection.Emit.Lightweight/4.0.0": { + "type": "package", + "dependencies": { + "System.Reflection": "4.0.0", + "System.Reflection.Emit.ILGeneration": "4.0.0", + "System.Reflection.Primitives": "4.0.0", + "System.Runtime": "4.0.0" + }, + "compile": { + "ref/dotnet/System.Reflection.Emit.Lightweight.dll": {} + }, + "runtime": { + "lib/netcore50/System.Reflection.Emit.Lightweight.dll": {} + } + }, + "System.Reflection.Extensions/4.0.0": { + "type": "package", + "dependencies": { + "System.Diagnostics.Debug": "4.0.10", + "System.Reflection": "4.0.10", + "System.Reflection.Primitives": "4.0.0", + "System.Reflection.TypeExtensions": "4.0.0", + "System.Resources.ResourceManager": "4.0.0", + "System.Runtime": "4.0.20", + "System.Runtime.Extensions": "4.0.10" + }, + "compile": { + "ref/netcore50/System.Reflection.Extensions.dll": {} + }, + "runtime": { + "lib/netcore50/System.Reflection.Extensions.dll": {} + } + }, + "System.Reflection.Metadata/1.0.22": { + "type": "package", + "dependencies": { + "System.Collections": "4.0.0", + "System.Collections.Immutable": "1.1.37", + "System.Diagnostics.Debug": "4.0.0", + "System.IO": "4.0.0", + "System.Reflection": "4.0.0", + "System.Reflection.Extensions": "4.0.0", + "System.Reflection.Primitives": "4.0.0", + "System.Resources.ResourceManager": "4.0.0", + "System.Runtime": "4.0.0", + "System.Runtime.Extensions": "4.0.0", + "System.Runtime.InteropServices": "4.0.0", + "System.Text.Encoding": "4.0.0", + "System.Text.Encoding.Extensions": "4.0.0", + "System.Threading": "4.0.0" + }, + "compile": { + "lib/dotnet/System.Reflection.Metadata.dll": {} + }, + "runtime": { + "lib/dotnet/System.Reflection.Metadata.dll": {} + } + }, + "System.Reflection.Primitives/4.0.0": { + "type": "package", + "dependencies": { + "System.Runtime": "4.0.0", + "System.Threading": "4.0.0" + }, + "compile": { + "ref/netcore50/System.Reflection.Primitives.dll": {} + }, + "runtime": { + "lib/netcore50/System.Reflection.Primitives.dll": {} + } + }, + "System.Reflection.TypeExtensions/4.0.0": { + "type": "package", + "dependencies": { + "System.Diagnostics.Contracts": "4.0.0", + "System.Diagnostics.Debug": "4.0.10", + "System.Linq": "4.0.0", + "System.Reflection": "4.0.10", + "System.Reflection.Primitives": "4.0.0", + "System.Resources.ResourceManager": "4.0.0", + "System.Runtime": "4.0.20", + "System.Runtime.Extensions": "4.0.10" + }, + "compile": { + "ref/dotnet/System.Reflection.TypeExtensions.dll": {} + }, + "runtime": { + "lib/netcore50/System.Reflection.TypeExtensions.dll": {} + } + }, + "System.Resources.ResourceManager/4.0.0": { + "type": "package", + "dependencies": { + "System.Globalization": "4.0.0", + "System.Reflection": "4.0.10", + "System.Runtime": "4.0.20" + }, + "compile": { + "ref/netcore50/System.Resources.ResourceManager.dll": {} + }, + "runtime": { + "lib/netcore50/System.Resources.ResourceManager.dll": {} + } + }, + "System.Runtime/4.0.20": { + "type": "package", + "dependencies": { + "System.Private.Uri": "4.0.0" + }, + "compile": { + "ref/dotnet/System.Runtime.dll": {} + }, + "runtime": { + "lib/netcore50/System.Runtime.dll": {} + } + }, + "System.Runtime.Extensions/4.0.10": { + "type": "package", + "dependencies": { + "System.Runtime": "4.0.20" + }, + "compile": { + "ref/dotnet/System.Runtime.Extensions.dll": {} + }, + "runtime": { + "lib/netcore50/System.Runtime.Extensions.dll": {} + } + }, + "System.Runtime.Handles/4.0.0": { + "type": "package", + "dependencies": { + "System.Runtime": "4.0.0" + }, + "compile": { + "ref/dotnet/System.Runtime.Handles.dll": {} + }, + "runtime": { + "lib/netcore50/System.Runtime.Handles.dll": {} + } + }, + "System.Runtime.InteropServices/4.0.20": { + "type": "package", + "dependencies": { + "System.Reflection": "4.0.0", + "System.Reflection.Primitives": "4.0.0", + "System.Runtime": "4.0.0", + "System.Runtime.Handles": "4.0.0" + }, + "compile": { + "ref/dotnet/System.Runtime.InteropServices.dll": {} + }, + "runtime": { + "lib/netcore50/System.Runtime.InteropServices.dll": {} + } + }, + "System.Runtime.InteropServices.WindowsRuntime/4.0.0": { + "type": "package", + "compile": { + "ref/netcore50/System.Runtime.InteropServices.WindowsRuntime.dll": {} + }, + "runtime": { + "lib/netcore50/System.Runtime.InteropServices.WindowsRuntime.dll": {} + } + }, + "System.Runtime.Numerics/4.0.0": { + "type": "package", + "dependencies": { + "System.Globalization": "4.0.10", + "System.Resources.ResourceManager": "4.0.0", + "System.Runtime": "4.0.20", + "System.Runtime.Extensions": "4.0.10" + }, + "compile": { + "ref/netcore50/System.Runtime.Numerics.dll": {} + }, + "runtime": { + "lib/netcore50/System.Runtime.Numerics.dll": {} + } + }, + "System.Runtime.WindowsRuntime/4.0.10": { + "type": "package", + "dependencies": { + "System.Diagnostics.Debug": "4.0.10", + "System.Globalization": "4.0.0", + "System.IO": "4.0.10", + "System.ObjectModel": "4.0.0", + "System.Resources.ResourceManager": "4.0.0", + "System.Runtime": "4.0.20", + "System.Runtime.Extensions": "4.0.0", + "System.Runtime.InteropServices": "4.0.20", + "System.Threading": "4.0.10", + "System.Threading.Tasks": "4.0.10" + }, + "compile": { + "ref/netcore50/System.Runtime.WindowsRuntime.dll": {} + }, + "runtime": { + "lib/netcore50/System.Runtime.WindowsRuntime.dll": {} + } + }, + "System.Security.Claims/4.0.0": { + "type": "package", + "dependencies": { + "System.Collections": "4.0.0", + "System.Diagnostics.Debug": "4.0.0", + "System.Globalization": "4.0.0", + "System.IO": "4.0.0", + "System.Resources.ResourceManager": "4.0.0", + "System.Runtime": "4.0.20", + "System.Runtime.Extensions": "4.0.0", + "System.Security.Principal": "4.0.0" + }, + "compile": { + "ref/dotnet/System.Security.Claims.dll": {} + }, + "runtime": { + "lib/dotnet/System.Security.Claims.dll": {} + } + }, + "System.Security.Principal/4.0.0": { + "type": "package", + "dependencies": { + "System.Runtime": "4.0.0" + }, + "compile": { + "ref/netcore50/System.Security.Principal.dll": {} + }, + "runtime": { + "lib/netcore50/System.Security.Principal.dll": {} + } + }, + "System.Text.Encoding/4.0.10": { + "type": "package", + "dependencies": { + "System.Runtime": "4.0.0" + }, + "compile": { + "ref/dotnet/System.Text.Encoding.dll": {} + }, + "runtime": { + "lib/netcore50/System.Text.Encoding.dll": {} + } + }, + "System.Text.Encoding.Extensions/4.0.10": { + "type": "package", + "dependencies": { + "System.Runtime": "4.0.0", + "System.Text.Encoding": "4.0.10" + }, + "compile": { + "ref/dotnet/System.Text.Encoding.Extensions.dll": {} + }, + "runtime": { + "lib/netcore50/System.Text.Encoding.Extensions.dll": {} + } + }, + "System.Text.RegularExpressions/4.0.10": { + "type": "package", + "dependencies": { + "System.Collections": "4.0.10", + "System.Globalization": "4.0.10", + "System.Resources.ResourceManager": "4.0.0", + "System.Runtime": "4.0.20", + "System.Runtime.Extensions": "4.0.10", + "System.Threading": "4.0.10" + }, + "compile": { + "ref/dotnet/System.Text.RegularExpressions.dll": {} + }, + "runtime": { + "lib/dotnet/System.Text.RegularExpressions.dll": {} + } + }, + "System.Threading/4.0.10": { + "type": "package", + "dependencies": { + "System.Runtime": "4.0.0", + "System.Threading.Tasks": "4.0.0" + }, + "compile": { + "ref/dotnet/System.Threading.dll": {} + }, + "runtime": { + "lib/netcore50/System.Threading.dll": {} + } + }, + "System.Threading.Overlapped/4.0.0": { + "type": "package", + "dependencies": { + "System.Resources.ResourceManager": "4.0.0", + "System.Runtime": "4.0.20", + "System.Runtime.Extensions": "4.0.0", + "System.Runtime.Handles": "4.0.0", + "System.Runtime.InteropServices": "4.0.20", + "System.Threading": "4.0.10" + }, + "compile": { + "ref/dotnet/System.Threading.Overlapped.dll": {} + }, + "runtime": { + "lib/netcore50/System.Threading.Overlapped.dll": {} + } + }, + "System.Threading.Tasks/4.0.10": { + "type": "package", + "dependencies": { + "System.Runtime": "4.0.0" + }, + "compile": { + "ref/dotnet/System.Threading.Tasks.dll": {} + }, + "runtime": { + "lib/netcore50/System.Threading.Tasks.dll": {} + } + }, + "System.Threading.Tasks.Dataflow/4.5.25": { + "type": "package", + "dependencies": { + "System.Collections": "4.0.0", + "System.Collections.Concurrent": "4.0.0", + "System.Diagnostics.Debug": "4.0.0", + "System.Diagnostics.Tracing": "4.0.0", + "System.Dynamic.Runtime": "4.0.0", + "System.Linq": "4.0.0", + "System.Resources.ResourceManager": "4.0.0", + "System.Runtime": "4.0.0", + "System.Runtime.Extensions": "4.0.0", + "System.Threading": "4.0.0", + "System.Threading.Tasks": "4.0.0" + }, + "compile": { + "lib/dotnet/System.Threading.Tasks.Dataflow.dll": {} + }, + "runtime": { + "lib/dotnet/System.Threading.Tasks.Dataflow.dll": {} + } + }, + "System.Threading.Tasks.Parallel/4.0.0": { + "type": "package", + "dependencies": { + "System.Collections.Concurrent": "4.0.10", + "System.Diagnostics.Debug": "4.0.10", + "System.Diagnostics.Tracing": "4.0.20", + "System.Resources.ResourceManager": "4.0.0", + "System.Runtime": "4.0.20", + "System.Runtime.Extensions": "4.0.10", + "System.Threading": "4.0.10", + "System.Threading.Tasks": "4.0.10" + }, + "compile": { + "ref/netcore50/System.Threading.Tasks.Parallel.dll": {} + }, + "runtime": { + "lib/netcore50/System.Threading.Tasks.Parallel.dll": {} + } + }, + "System.Threading.Timer/4.0.0": { + "type": "package", + "compile": { + "ref/netcore50/System.Threading.Timer.dll": {} + }, + "runtime": { + "lib/netcore50/System.Threading.Timer.dll": {} + } + }, + "System.Xml.ReaderWriter/4.0.10": { + "type": "package", + "dependencies": { + "System.Collections": "4.0.10", + "System.Diagnostics.Debug": "4.0.10", + "System.Globalization": "4.0.10", + "System.IO": "4.0.10", + "System.IO.FileSystem": "4.0.0", + "System.IO.FileSystem.Primitives": "4.0.0", + "System.Resources.ResourceManager": "4.0.0", + "System.Runtime": "4.0.20", + "System.Runtime.Extensions": "4.0.10", + "System.Runtime.InteropServices": "4.0.20", + "System.Text.Encoding": "4.0.10", + "System.Text.Encoding.Extensions": "4.0.10", + "System.Text.RegularExpressions": "4.0.10", + "System.Threading.Tasks": "4.0.10" + }, + "compile": { + "ref/dotnet/System.Xml.ReaderWriter.dll": {} + }, + "runtime": { + "lib/dotnet/System.Xml.ReaderWriter.dll": {} + } + }, + "System.Xml.XDocument/4.0.10": { + "type": "package", + "dependencies": { + "System.Collections": "4.0.10", + "System.Diagnostics.Debug": "4.0.10", + "System.Globalization": "4.0.10", + "System.IO": "4.0.10", + "System.Reflection": "4.0.10", + "System.Resources.ResourceManager": "4.0.0", + "System.Runtime": "4.0.20", + "System.Runtime.Extensions": "4.0.10", + "System.Text.Encoding": "4.0.10", + "System.Threading": "4.0.10", + "System.Xml.ReaderWriter": "4.0.10" + }, + "compile": { + "ref/dotnet/System.Xml.XDocument.dll": {} + }, + "runtime": { + "lib/dotnet/System.Xml.XDocument.dll": {} + } + } + }, + "UAP,Version=v10.0/win10-x64-aot": { + "Microsoft.CSharp/4.0.0": { + "type": "package", + "dependencies": { + "System.Collections": "4.0.10", + "System.Diagnostics.Debug": "4.0.10", + "System.Dynamic.Runtime": "4.0.0", + "System.Globalization": "4.0.10", + "System.Linq": "4.0.0", + "System.Linq.Expressions": "4.0.0", + "System.ObjectModel": "4.0.10", + "System.Reflection": "4.0.10", + "System.Reflection.Extensions": "4.0.0", + "System.Reflection.Primitives": "4.0.0", + "System.Reflection.TypeExtensions": "4.0.0", + "System.Resources.ResourceManager": "4.0.0", + "System.Runtime": "4.0.20", + "System.Runtime.Extensions": "4.0.10", + "System.Runtime.InteropServices": "4.0.20", + "System.Threading": "4.0.10" + }, + "compile": { + "ref/netcore50/Microsoft.CSharp.dll": {} + }, + "runtime": { + "lib/netcore50/Microsoft.CSharp.dll": {} + } + }, + "Microsoft.NETCore/5.0.0": { + "type": "package", + "dependencies": { + "Microsoft.CSharp": "4.0.0", + "Microsoft.NETCore.Targets": "1.0.0", + "Microsoft.VisualBasic": "10.0.0", + "System.AppContext": "4.0.0", + "System.Collections": "4.0.10", + "System.Collections.Concurrent": "4.0.10", + "System.Collections.Immutable": "1.1.37", + "System.ComponentModel": "4.0.0", + "System.ComponentModel.Annotations": "4.0.10", + "System.Diagnostics.Debug": "4.0.10", + "System.Diagnostics.Tools": "4.0.0", + "System.Diagnostics.Tracing": "4.0.20", + "System.Dynamic.Runtime": "4.0.10", + "System.Globalization": "4.0.10", + "System.Globalization.Calendars": "4.0.0", + "System.Globalization.Extensions": "4.0.0", + "System.IO": "4.0.10", + "System.IO.Compression": "4.0.0", + "System.IO.Compression.ZipFile": "4.0.0", + "System.IO.FileSystem": "4.0.0", + "System.IO.FileSystem.Primitives": "4.0.0", + "System.IO.UnmanagedMemoryStream": "4.0.0", + "System.Linq": "4.0.0", + "System.Linq.Expressions": "4.0.10", + "System.Linq.Parallel": "4.0.0", + "System.Linq.Queryable": "4.0.0", + "System.Net.Http": "4.0.0", + "System.Net.NetworkInformation": "4.0.0", + "System.Net.Primitives": "4.0.10", + "System.Numerics.Vectors": "4.1.0", + "System.ObjectModel": "4.0.10", + "System.Reflection": "4.0.10", + "System.Reflection.DispatchProxy": "4.0.0", + "System.Reflection.Extensions": "4.0.0", + "System.Reflection.Metadata": "1.0.22", + "System.Reflection.Primitives": "4.0.0", + "System.Reflection.TypeExtensions": "4.0.0", + "System.Resources.ResourceManager": "4.0.0", + "System.Runtime": "4.0.20", + "System.Runtime.Extensions": "4.0.10", + "System.Runtime.Handles": "4.0.0", + "System.Runtime.InteropServices": "4.0.20", + "System.Runtime.Numerics": "4.0.0", + "System.Security.Claims": "4.0.0", + "System.Security.Principal": "4.0.0", + "System.Text.Encoding": "4.0.10", + "System.Text.Encoding.Extensions": "4.0.10", + "System.Text.RegularExpressions": "4.0.10", + "System.Threading": "4.0.10", + "System.Threading.Tasks": "4.0.10", + "System.Threading.Tasks.Dataflow": "4.5.25", + "System.Threading.Tasks.Parallel": "4.0.0", + "System.Threading.Timer": "4.0.0", + "System.Xml.ReaderWriter": "4.0.10", + "System.Xml.XDocument": "4.0.10" + } + }, + "Microsoft.NETCore.Platforms/1.0.0": { + "type": "package" + }, + "Microsoft.NETCore.Portable.Compatibility/1.0.0": { + "type": "package", + "dependencies": { + "Microsoft.NETCore.Runtime": "1.0.0" + }, + "compile": { + "ref/netcore50/System.ComponentModel.DataAnnotations.dll": {}, + "ref/netcore50/System.Core.dll": {}, + "ref/netcore50/System.Net.dll": {}, + "ref/netcore50/System.Numerics.dll": {}, + "ref/netcore50/System.Runtime.Serialization.dll": {}, + "ref/netcore50/System.ServiceModel.Web.dll": {}, + "ref/netcore50/System.ServiceModel.dll": {}, + "ref/netcore50/System.Windows.dll": {}, + "ref/netcore50/System.Xml.Linq.dll": {}, + "ref/netcore50/System.Xml.Serialization.dll": {}, + "ref/netcore50/System.Xml.dll": {}, + "ref/netcore50/System.dll": {}, + "ref/netcore50/mscorlib.dll": {} + }, + "runtime": { + "runtimes/aot/lib/netcore50/System.ComponentModel.DataAnnotations.dll": {}, + "runtimes/aot/lib/netcore50/System.Core.dll": {}, + "runtimes/aot/lib/netcore50/System.Net.dll": {}, + "runtimes/aot/lib/netcore50/System.Numerics.dll": {}, + "runtimes/aot/lib/netcore50/System.Runtime.Serialization.dll": {}, + "runtimes/aot/lib/netcore50/System.ServiceModel.Web.dll": {}, + "runtimes/aot/lib/netcore50/System.ServiceModel.dll": {}, + "runtimes/aot/lib/netcore50/System.Windows.dll": {}, + "runtimes/aot/lib/netcore50/System.Xml.Linq.dll": {}, + "runtimes/aot/lib/netcore50/System.Xml.Serialization.dll": {}, + "runtimes/aot/lib/netcore50/System.Xml.dll": {}, + "runtimes/aot/lib/netcore50/System.dll": {}, + "runtimes/aot/lib/netcore50/mscorlib.dll": {} + } + }, + "Microsoft.NETCore.Runtime/1.0.0": { + "type": "package", + "dependencies": { + "Microsoft.NETCore.Runtime.Native": "1.0.0" + } + }, + "Microsoft.NETCore.Runtime.Native/1.0.0": { + "type": "package", + "dependencies": { + "System.Collections": "[4.0.10]", + "System.Diagnostics.Contracts": "[4.0.0]", + "System.Diagnostics.Debug": "[4.0.10]", + "System.Diagnostics.StackTrace": "[4.0.0]", + "System.Diagnostics.Tools": "[4.0.0]", + "System.Diagnostics.Tracing": "[4.0.20]", + "System.Globalization": "[4.0.10]", + "System.Globalization.Calendars": "[4.0.0]", + "System.IO": "[4.0.10]", + "System.ObjectModel": "[4.0.10]", + "System.Private.Uri": "[4.0.0]", + "System.Reflection": "[4.0.10]", + "System.Reflection.Extensions": "[4.0.0]", + "System.Reflection.Primitives": "[4.0.0]", + "System.Resources.ResourceManager": "[4.0.0]", + "System.Runtime": "[4.0.20]", + "System.Runtime.Extensions": "[4.0.10]", + "System.Runtime.Handles": "[4.0.0]", + "System.Runtime.InteropServices": "[4.0.20]", + "System.Text.Encoding": "[4.0.10]", + "System.Text.Encoding.Extensions": "[4.0.10]", + "System.Threading": "[4.0.10]", + "System.Threading.Tasks": "[4.0.10]", + "System.Threading.Timer": "[4.0.0]" + } + }, + "Microsoft.NETCore.Targets/1.0.0": { + "type": "package", + "dependencies": { + "Microsoft.NETCore.Platforms": "1.0.0", + "Microsoft.NETCore.Targets.UniversalWindowsPlatform": "5.0.0" + } + }, + "Microsoft.NETCore.Targets.UniversalWindowsPlatform/5.0.0": { + "type": "package" + }, + "Microsoft.VisualBasic/10.0.0": { + "type": "package", + "dependencies": { + "System.Collections": "4.0.10", + "System.Diagnostics.Debug": "4.0.10", + "System.Dynamic.Runtime": "4.0.10", + "System.Globalization": "4.0.10", + "System.Linq": "4.0.0", + "System.Linq.Expressions": "4.0.10", + "System.ObjectModel": "4.0.10", + "System.Reflection": "4.0.10", + "System.Reflection.Extensions": "4.0.0", + "System.Reflection.Primitives": "4.0.0", + "System.Reflection.TypeExtensions": "4.0.0", + "System.Resources.ResourceManager": "4.0.0", + "System.Runtime": "4.0.20", + "System.Runtime.Extensions": "4.0.10", + "System.Runtime.InteropServices": "4.0.20", + "System.Threading": "4.0.10" + }, + "compile": { + "ref/netcore50/Microsoft.VisualBasic.dll": {} + }, + "runtime": { + "lib/netcore50/Microsoft.VisualBasic.dll": {} + } + }, + "Microsoft.Win32.Primitives/4.0.0": { + "type": "package", + "dependencies": { + "System.Runtime": "4.0.20", + "System.Runtime.InteropServices": "4.0.20" + }, + "compile": { + "ref/dotnet/Microsoft.Win32.Primitives.dll": {} + }, + "runtime": { + "lib/dotnet/Microsoft.Win32.Primitives.dll": {} + } + }, + "System.AppContext/4.0.0": { + "type": "package", + "dependencies": { + "System.Collections": "4.0.0", + "System.Resources.ResourceManager": "4.0.0", + "System.Runtime": "4.0.20", + "System.Threading": "4.0.0" + }, + "compile": { + "ref/dotnet/System.AppContext.dll": {} + }, + "runtime": { + "lib/netcore50/System.AppContext.dll": {} + } + }, + "System.Collections/4.0.10": { + "type": "package", + "dependencies": { + "System.Diagnostics.Debug": "4.0.0", + "System.Resources.ResourceManager": "4.0.0", + "System.Runtime": "4.0.20", + "System.Runtime.Extensions": "4.0.0", + "System.Threading": "4.0.0" + }, + "compile": { + "ref/dotnet/System.Collections.dll": {} + }, + "runtime": { + "runtimes/win8-aot/lib/netcore50/System.Collections.dll": {} + } + }, + "System.Collections.Concurrent/4.0.10": { + "type": "package", + "dependencies": { + "System.Collections": "4.0.10", + "System.Diagnostics.Debug": "4.0.10", + "System.Diagnostics.Tracing": "4.0.20", + "System.Globalization": "4.0.10", + "System.Resources.ResourceManager": "4.0.0", + "System.Runtime": "4.0.20", + "System.Runtime.Extensions": "4.0.10", + "System.Threading": "4.0.10", + "System.Threading.Tasks": "4.0.10" + }, + "compile": { + "ref/dotnet/System.Collections.Concurrent.dll": {} + }, + "runtime": { + "lib/dotnet/System.Collections.Concurrent.dll": {} + } + }, + "System.Collections.Immutable/1.1.37": { + "type": "package", + "dependencies": { + "System.Collections": "4.0.0", + "System.Diagnostics.Debug": "4.0.0", + "System.Globalization": "4.0.0", + "System.Linq": "4.0.0", + "System.Resources.ResourceManager": "4.0.0", + "System.Runtime": "4.0.0", + "System.Runtime.Extensions": "4.0.0", + "System.Threading": "4.0.0" + }, + "compile": { + "lib/dotnet/System.Collections.Immutable.dll": {} + }, + "runtime": { + "lib/dotnet/System.Collections.Immutable.dll": {} + } + }, + "System.Collections.NonGeneric/4.0.0": { + "type": "package", + "dependencies": { + "System.Diagnostics.Debug": "4.0.10", + "System.Globalization": "4.0.10", + "System.Resources.ResourceManager": "4.0.0", + "System.Runtime": "4.0.20", + "System.Runtime.Extensions": "4.0.10", + "System.Threading": "4.0.10" + }, + "compile": { + "ref/dotnet/System.Collections.NonGeneric.dll": {} + }, + "runtime": { + "lib/dotnet/System.Collections.NonGeneric.dll": {} + } + }, + "System.ComponentModel/4.0.0": { + "type": "package", + "dependencies": { + "System.Runtime": "4.0.20" + }, + "compile": { + "ref/netcore50/System.ComponentModel.dll": {} + }, + "runtime": { + "lib/netcore50/System.ComponentModel.dll": {} + } + }, + "System.ComponentModel.Annotations/4.0.10": { + "type": "package", + "dependencies": { + "System.Collections": "4.0.10", + "System.ComponentModel": "4.0.0", + "System.Globalization": "4.0.10", + "System.Linq": "4.0.0", + "System.Reflection": "4.0.10", + "System.Reflection.Extensions": "4.0.0", + "System.Resources.ResourceManager": "4.0.0", + "System.Runtime": "4.0.20", + "System.Runtime.Extensions": "4.0.10", + "System.Text.RegularExpressions": "4.0.10", + "System.Threading": "4.0.10" + }, + "compile": { + "ref/dotnet/System.ComponentModel.Annotations.dll": {} + }, + "runtime": { + "lib/dotnet/System.ComponentModel.Annotations.dll": {} + } + }, + "System.Diagnostics.Contracts/4.0.0": { + "type": "package", + "compile": { + "ref/netcore50/System.Diagnostics.Contracts.dll": {} + }, + "runtime": { + "runtimes/win8-aot/lib/netcore50/System.Diagnostics.Contracts.dll": {} + } + }, + "System.Diagnostics.Debug/4.0.10": { + "type": "package", + "dependencies": { + "System.Runtime": "4.0.0" + }, + "compile": { + "ref/dotnet/System.Diagnostics.Debug.dll": {} + }, + "runtime": { + "runtimes/win8-aot/lib/netcore50/System.Diagnostics.Debug.dll": {} + } + }, + "System.Diagnostics.StackTrace/4.0.0": { + "type": "package", + "dependencies": { + "System.Runtime": "4.0.20" + }, + "compile": { + "ref/dotnet/System.Diagnostics.StackTrace.dll": {} + }, + "runtime": { + "runtimes/win8-aot/lib/netcore50/System.Diagnostics.StackTrace.dll": {} + } + }, + "System.Diagnostics.Tools/4.0.0": { + "type": "package", + "compile": { + "ref/netcore50/System.Diagnostics.Tools.dll": {} + }, + "runtime": { + "runtimes/win8-aot/lib/netcore50/System.Diagnostics.Tools.dll": {} + } + }, + "System.Diagnostics.Tracing/4.0.20": { + "type": "package", + "dependencies": { + "System.Collections": "4.0.10", + "System.Globalization": "4.0.0", + "System.Reflection": "4.0.10", + "System.Reflection.Extensions": "4.0.0", + "System.Resources.ResourceManager": "4.0.0", + "System.Runtime": "4.0.20", + "System.Runtime.Extensions": "4.0.10", + "System.Runtime.InteropServices": "4.0.0", + "System.Text.Encoding": "4.0.0", + "System.Threading": "4.0.10" + }, + "compile": { + "ref/dotnet/System.Diagnostics.Tracing.dll": {} + }, + "runtime": { + "runtimes/win8-aot/lib/netcore50/System.Diagnostics.Tracing.dll": {} + } + }, + "System.Dynamic.Runtime/4.0.10": { + "type": "package", + "dependencies": { + "System.Collections": "4.0.0", + "System.Diagnostics.Debug": "4.0.0", + "System.Globalization": "4.0.0", + "System.Linq": "4.0.0", + "System.Linq.Expressions": "4.0.10", + "System.ObjectModel": "4.0.0", + "System.Reflection": "4.0.0", + "System.Reflection.TypeExtensions": "4.0.0", + "System.Resources.ResourceManager": "4.0.0", + "System.Runtime": "4.0.20", + "System.Runtime.Extensions": "4.0.0", + "System.Threading": "4.0.0" + }, + "compile": { + "ref/dotnet/System.Dynamic.Runtime.dll": {} + }, + "runtime": { + "runtimes/win8-aot/lib/netcore50/System.Dynamic.Runtime.dll": {} + } + }, + "System.Globalization/4.0.10": { + "type": "package", + "dependencies": { + "System.Runtime": "4.0.0" + }, + "compile": { + "ref/dotnet/System.Globalization.dll": {} + }, + "runtime": { + "runtimes/win8-aot/lib/netcore50/System.Globalization.dll": {} + } + }, + "System.Globalization.Calendars/4.0.0": { + "type": "package", + "dependencies": { + "System.Globalization": "4.0.0", + "System.Runtime": "4.0.0" + }, + "compile": { + "ref/dotnet/System.Globalization.Calendars.dll": {} + }, + "runtime": { + "runtimes/win8-aot/lib/netcore50/System.Globalization.Calendars.dll": {} + } + }, + "System.Globalization.Extensions/4.0.0": { + "type": "package", + "dependencies": { + "System.Globalization": "4.0.10", + "System.Resources.ResourceManager": "4.0.0", + "System.Runtime": "4.0.20", + "System.Runtime.Extensions": "4.0.10", + "System.Runtime.InteropServices": "4.0.20" + }, + "compile": { + "ref/dotnet/System.Globalization.Extensions.dll": {} + }, + "runtime": { + "lib/dotnet/System.Globalization.Extensions.dll": {} + } + }, + "System.IO/4.0.10": { + "type": "package", + "dependencies": { + "System.Globalization": "4.0.0", + "System.Runtime": "4.0.20", + "System.Text.Encoding": "4.0.10", + "System.Text.Encoding.Extensions": "4.0.0", + "System.Threading": "4.0.0", + "System.Threading.Tasks": "4.0.0" + }, + "compile": { + "ref/dotnet/System.IO.dll": {} + }, + "runtime": { + "runtimes/win8-aot/lib/netcore50/System.IO.dll": {} + } + }, + "System.IO.Compression/4.0.0": { + "type": "package", + "dependencies": { + "System.Collections": "4.0.0", + "System.IO": "4.0.0", + "System.IO.Compression.clrcompression-x64": "4.0.0", + "System.Resources.ResourceManager": "4.0.0", + "System.Runtime": "4.0.0", + "System.Runtime.Extensions": "4.0.0", + "System.Runtime.InteropServices": "4.0.0", + "System.Text.Encoding": "4.0.0", + "System.Threading": "4.0.0", + "System.Threading.Tasks": "4.0.0" + }, + "compile": { + "ref/netcore50/System.IO.Compression.dll": {} + }, + "runtime": { + "lib/netcore50/System.IO.Compression.dll": {} + } + }, + "System.IO.Compression.clrcompression-x64/4.0.0": { + "type": "package", + "native": { + "runtimes/win10-x64/native/ClrCompression.dll": {} + } + }, + "System.IO.Compression.ZipFile/4.0.0": { + "type": "package", + "dependencies": { + "System.IO": "4.0.10", + "System.IO.Compression": "4.0.0", + "System.IO.FileSystem": "4.0.0", + "System.IO.FileSystem.Primitives": "4.0.0", + "System.Resources.ResourceManager": "4.0.0", + "System.Runtime": "4.0.20", + "System.Runtime.Extensions": "4.0.10", + "System.Text.Encoding": "4.0.10" + }, + "compile": { + "ref/dotnet/System.IO.Compression.ZipFile.dll": {} + }, + "runtime": { + "lib/dotnet/System.IO.Compression.ZipFile.dll": {} + } + }, + "System.IO.FileSystem/4.0.0": { + "type": "package", + "dependencies": { + "System.Collections": "4.0.10", + "System.Diagnostics.Debug": "4.0.10", + "System.IO": "4.0.10", + "System.IO.FileSystem.Primitives": "4.0.0", + "System.Resources.ResourceManager": "4.0.0", + "System.Runtime": "4.0.20", + "System.Runtime.Extensions": "4.0.10", + "System.Runtime.Handles": "4.0.0", + "System.Runtime.InteropServices": "4.0.20", + "System.Runtime.WindowsRuntime": "4.0.0", + "System.Text.Encoding": "4.0.10", + "System.Text.Encoding.Extensions": "4.0.10", + "System.Threading": "4.0.10", + "System.Threading.Overlapped": "4.0.0", + "System.Threading.Tasks": "4.0.10" + }, + "compile": { + "ref/dotnet/System.IO.FileSystem.dll": {} + }, + "runtime": { + "lib/netcore50/System.IO.FileSystem.dll": {} + } + }, + "System.IO.FileSystem.Primitives/4.0.0": { + "type": "package", + "dependencies": { + "System.Runtime": "4.0.20" + }, + "compile": { + "ref/dotnet/System.IO.FileSystem.Primitives.dll": {} + }, + "runtime": { + "lib/dotnet/System.IO.FileSystem.Primitives.dll": {} + } + }, + "System.IO.UnmanagedMemoryStream/4.0.0": { + "type": "package", + "dependencies": { + "System.IO": "4.0.10", + "System.IO.FileSystem.Primitives": "4.0.0", + "System.Resources.ResourceManager": "4.0.0", + "System.Runtime": "4.0.20", + "System.Runtime.InteropServices": "4.0.20", + "System.Threading": "4.0.10", + "System.Threading.Tasks": "4.0.10" + }, + "compile": { + "ref/dotnet/System.IO.UnmanagedMemoryStream.dll": {} + }, + "runtime": { + "lib/dotnet/System.IO.UnmanagedMemoryStream.dll": {} + } + }, + "System.Linq/4.0.0": { + "type": "package", + "dependencies": { + "System.Collections": "4.0.10", + "System.Diagnostics.Debug": "4.0.10", + "System.Resources.ResourceManager": "4.0.0", + "System.Runtime": "4.0.20", + "System.Runtime.Extensions": "4.0.10" + }, + "compile": { + "ref/netcore50/System.Linq.dll": {} + }, + "runtime": { + "lib/netcore50/System.Linq.dll": {} + } + }, + "System.Linq.Expressions/4.0.10": { + "type": "package", + "dependencies": { + "System.Collections": "4.0.0", + "System.Diagnostics.Debug": "4.0.0", + "System.Globalization": "4.0.0", + "System.IO": "4.0.0", + "System.Linq": "4.0.0", + "System.Reflection": "4.0.0", + "System.Reflection.Extensions": "4.0.0", + "System.Reflection.Primitives": "4.0.0", + "System.Reflection.TypeExtensions": "4.0.0", + "System.Resources.ResourceManager": "4.0.0", + "System.Runtime": "4.0.20", + "System.Runtime.Extensions": "4.0.0", + "System.Threading": "4.0.0" + }, + "compile": { + "ref/dotnet/System.Linq.Expressions.dll": {} + }, + "runtime": { + "runtimes/win8-aot/lib/netcore50/System.Linq.Expressions.dll": {} + } + }, + "System.Linq.Parallel/4.0.0": { + "type": "package", + "dependencies": { + "System.Collections": "4.0.10", + "System.Collections.Concurrent": "4.0.10", + "System.Diagnostics.Debug": "4.0.10", + "System.Diagnostics.Tracing": "4.0.20", + "System.Linq": "4.0.0", + "System.Resources.ResourceManager": "4.0.0", + "System.Runtime": "4.0.20", + "System.Runtime.Extensions": "4.0.10", + "System.Threading": "4.0.10", + "System.Threading.Tasks": "4.0.10" + }, + "compile": { + "ref/netcore50/System.Linq.Parallel.dll": {} + }, + "runtime": { + "lib/netcore50/System.Linq.Parallel.dll": {} + } + }, + "System.Linq.Queryable/4.0.0": { + "type": "package", + "dependencies": { + "System.Collections": "4.0.10", + "System.Linq": "4.0.0", + "System.Linq.Expressions": "4.0.10", + "System.Reflection": "4.0.10", + "System.Reflection.Extensions": "4.0.0", + "System.Resources.ResourceManager": "4.0.0", + "System.Runtime": "4.0.20" + }, + "compile": { + "ref/netcore50/System.Linq.Queryable.dll": {} + }, + "runtime": { + "lib/netcore50/System.Linq.Queryable.dll": {} + } + }, + "System.Net.Http/4.0.0": { + "type": "package", + "dependencies": { + "System.Collections": "4.0.10", + "System.Diagnostics.Debug": "4.0.10", + "System.Globalization": "4.0.10", + "System.IO": "4.0.10", + "System.Net.Primitives": "4.0.0", + "System.Resources.ResourceManager": "4.0.0", + "System.Runtime": "4.0.20", + "System.Runtime.Extensions": "4.0.10", + "System.Runtime.InteropServices": "4.0.20", + "System.Runtime.WindowsRuntime": "4.0.10", + "System.Text.Encoding": "4.0.10", + "System.Text.Encoding.Extensions": "4.0.10", + "System.Threading": "4.0.10", + "System.Threading.Tasks": "4.0.10" + }, + "compile": { + "ref/netcore50/System.Net.Http.dll": {} + }, + "runtime": { + "lib/netcore50/System.Net.Http.dll": {} + } + }, + "System.Net.NetworkInformation/4.0.0": { + "type": "package", + "dependencies": { + "System.Runtime": "4.0.0", + "System.Runtime.InteropServices.WindowsRuntime": "4.0.0", + "System.Threading": "4.0.0" + }, + "compile": { + "ref/netcore50/System.Net.NetworkInformation.dll": {} + }, + "runtime": { + "lib/netcore50/System.Net.NetworkInformation.dll": {} + } + }, + "System.Net.Primitives/4.0.10": { + "type": "package", + "dependencies": { + "System.Private.Networking": "4.0.0", + "System.Runtime": "4.0.20" + }, + "compile": { + "ref/dotnet/System.Net.Primitives.dll": {} + }, + "runtime": { + "lib/netcore50/System.Net.Primitives.dll": {} + } + }, + "System.Numerics.Vectors/4.1.0": { + "type": "package", + "dependencies": { + "System.Globalization": "4.0.10", + "System.Resources.ResourceManager": "4.0.0", + "System.Runtime": "4.0.20", + "System.Runtime.Extensions": "4.0.10" + }, + "compile": { + "ref/dotnet/System.Numerics.Vectors.dll": {} + }, + "runtime": { + "lib/dotnet/System.Numerics.Vectors.dll": {} + } + }, + "System.ObjectModel/4.0.10": { + "type": "package", + "dependencies": { + "System.Collections": "4.0.10", + "System.Diagnostics.Debug": "4.0.10", + "System.Resources.ResourceManager": "4.0.0", + "System.Runtime": "4.0.20", + "System.Threading": "4.0.10" + }, + "compile": { + "ref/dotnet/System.ObjectModel.dll": {} + }, + "runtime": { + "lib/dotnet/System.ObjectModel.dll": {} + } + }, + "System.Private.Networking/4.0.0": { + "type": "package", + "dependencies": { + "Microsoft.Win32.Primitives": "4.0.0", + "System.Collections": "4.0.10", + "System.Collections.NonGeneric": "4.0.0", + "System.Diagnostics.Debug": "4.0.10", + "System.Diagnostics.Tracing": "4.0.20", + "System.Globalization": "4.0.10", + "System.IO": "4.0.10", + "System.IO.FileSystem": "4.0.0", + "System.IO.FileSystem.Primitives": "4.0.0", + "System.Resources.ResourceManager": "4.0.0", + "System.Runtime": "4.0.20", + "System.Runtime.Extensions": "4.0.10", + "System.Runtime.Handles": "4.0.0", + "System.Runtime.InteropServices": "4.0.20", + "System.Threading": "4.0.10", + "System.Threading.Overlapped": "4.0.0", + "System.Threading.Tasks": "4.0.10" + }, + "compile": { + "ref/netcore50/_._": {} + }, + "runtime": { + "lib/netcore50/System.Private.Networking.dll": {} + } + }, + "System.Private.Uri/4.0.0": { + "type": "package", + "compile": { + "ref/netcore50/_._": {} + }, + "runtime": { + "runtimes/win8-aot/lib/netcore50/System.Private.Uri.dll": {} + } + }, + "System.Reflection/4.0.10": { + "type": "package", + "dependencies": { + "System.IO": "4.0.0", + "System.Reflection.Primitives": "4.0.0", + "System.Runtime": "4.0.20" + }, + "compile": { + "ref/dotnet/System.Reflection.dll": {} + }, + "runtime": { + "runtimes/win8-aot/lib/netcore50/System.Reflection.dll": {} + } + }, + "System.Reflection.DispatchProxy/4.0.0": { + "type": "package", + "dependencies": { + "System.Collections": "4.0.10", + "System.Linq": "4.0.0", + "System.Reflection": "4.0.10", + "System.Reflection.Extensions": "4.0.0", + "System.Reflection.Primitives": "4.0.0", + "System.Resources.ResourceManager": "4.0.0", + "System.Runtime": "4.0.20", + "System.Threading": "4.0.10" + }, + "compile": { + "ref/dotnet/System.Reflection.DispatchProxy.dll": {} + }, + "runtime": { + "runtimes/win8-aot/lib/netcore50/System.Reflection.DispatchProxy.dll": {} + } + }, + "System.Reflection.Extensions/4.0.0": { + "type": "package", + "dependencies": { + "System.Diagnostics.Debug": "4.0.10", + "System.Reflection": "4.0.10", + "System.Reflection.Primitives": "4.0.0", + "System.Reflection.TypeExtensions": "4.0.0", + "System.Resources.ResourceManager": "4.0.0", + "System.Runtime": "4.0.20", + "System.Runtime.Extensions": "4.0.10" + }, + "compile": { + "ref/netcore50/System.Reflection.Extensions.dll": {} + }, + "runtime": { + "runtimes/win8-aot/lib/netcore50/System.Reflection.Extensions.dll": {} + } + }, + "System.Reflection.Metadata/1.0.22": { + "type": "package", + "dependencies": { + "System.Collections": "4.0.0", + "System.Collections.Immutable": "1.1.37", + "System.Diagnostics.Debug": "4.0.0", + "System.IO": "4.0.0", + "System.Reflection": "4.0.0", + "System.Reflection.Extensions": "4.0.0", + "System.Reflection.Primitives": "4.0.0", + "System.Resources.ResourceManager": "4.0.0", + "System.Runtime": "4.0.0", + "System.Runtime.Extensions": "4.0.0", + "System.Runtime.InteropServices": "4.0.0", + "System.Text.Encoding": "4.0.0", + "System.Text.Encoding.Extensions": "4.0.0", + "System.Threading": "4.0.0" + }, + "compile": { + "lib/dotnet/System.Reflection.Metadata.dll": {} + }, + "runtime": { + "lib/dotnet/System.Reflection.Metadata.dll": {} + } + }, + "System.Reflection.Primitives/4.0.0": { + "type": "package", + "dependencies": { + "System.Runtime": "4.0.0", + "System.Threading": "4.0.0" + }, + "compile": { + "ref/netcore50/System.Reflection.Primitives.dll": {} + }, + "runtime": { + "runtimes/win8-aot/lib/netcore50/System.Reflection.Primitives.dll": {} + } + }, + "System.Reflection.TypeExtensions/4.0.0": { + "type": "package", + "dependencies": { + "System.Diagnostics.Contracts": "4.0.0", + "System.Diagnostics.Debug": "4.0.10", + "System.Linq": "4.0.0", + "System.Reflection": "4.0.10", + "System.Reflection.Primitives": "4.0.0", + "System.Resources.ResourceManager": "4.0.0", + "System.Runtime": "4.0.20", + "System.Runtime.Extensions": "4.0.10" + }, + "compile": { + "ref/dotnet/System.Reflection.TypeExtensions.dll": {} + }, + "runtime": { + "runtimes/win8-aot/lib/netcore50/System.Reflection.TypeExtensions.dll": {} + } + }, + "System.Resources.ResourceManager/4.0.0": { + "type": "package", + "dependencies": { + "System.Globalization": "4.0.0", + "System.Reflection": "4.0.10", + "System.Runtime": "4.0.20" + }, + "compile": { + "ref/netcore50/System.Resources.ResourceManager.dll": {} + }, + "runtime": { + "runtimes/win8-aot/lib/netcore50/System.Resources.ResourceManager.dll": {} + } + }, + "System.Runtime/4.0.20": { + "type": "package", + "dependencies": { + "System.Private.Uri": "4.0.0" + }, + "compile": { + "ref/dotnet/System.Runtime.dll": {} + }, + "runtime": { + "runtimes/win8-aot/lib/netcore50/System.Runtime.dll": {} + } + }, + "System.Runtime.Extensions/4.0.10": { + "type": "package", + "dependencies": { + "System.Runtime": "4.0.20" + }, + "compile": { + "ref/dotnet/System.Runtime.Extensions.dll": {} + }, + "runtime": { + "runtimes/win8-aot/lib/netcore50/System.Runtime.Extensions.dll": {} + } + }, + "System.Runtime.Handles/4.0.0": { + "type": "package", + "dependencies": { + "System.Runtime": "4.0.0" + }, + "compile": { + "ref/dotnet/System.Runtime.Handles.dll": {} + }, + "runtime": { + "runtimes/win8-aot/lib/netcore50/System.Runtime.Handles.dll": {} + } + }, + "System.Runtime.InteropServices/4.0.20": { + "type": "package", + "dependencies": { + "System.Reflection": "4.0.0", + "System.Reflection.Primitives": "4.0.0", + "System.Runtime": "4.0.0", + "System.Runtime.Handles": "4.0.0" + }, + "compile": { + "ref/dotnet/System.Runtime.InteropServices.dll": {} + }, + "runtime": { + "runtimes/win8-aot/lib/netcore50/System.Runtime.InteropServices.dll": {} + } + }, + "System.Runtime.InteropServices.WindowsRuntime/4.0.0": { + "type": "package", + "compile": { + "ref/netcore50/System.Runtime.InteropServices.WindowsRuntime.dll": {} + }, + "runtime": { + "runtimes/win8-aot/lib/netcore50/System.Runtime.InteropServices.WindowsRuntime.dll": {} + } + }, + "System.Runtime.Numerics/4.0.0": { + "type": "package", + "dependencies": { + "System.Globalization": "4.0.10", + "System.Resources.ResourceManager": "4.0.0", + "System.Runtime": "4.0.20", + "System.Runtime.Extensions": "4.0.10" + }, + "compile": { + "ref/netcore50/System.Runtime.Numerics.dll": {} + }, + "runtime": { + "lib/netcore50/System.Runtime.Numerics.dll": {} + } + }, + "System.Runtime.WindowsRuntime/4.0.10": { + "type": "package", + "dependencies": { + "System.Diagnostics.Debug": "4.0.10", + "System.Globalization": "4.0.0", + "System.IO": "4.0.10", + "System.ObjectModel": "4.0.0", + "System.Resources.ResourceManager": "4.0.0", + "System.Runtime": "4.0.20", + "System.Runtime.Extensions": "4.0.0", + "System.Runtime.InteropServices": "4.0.20", + "System.Threading": "4.0.10", + "System.Threading.Tasks": "4.0.10" + }, + "compile": { + "ref/netcore50/System.Runtime.WindowsRuntime.dll": {} + }, + "runtime": { + "runtimes/win8-aot/lib/netcore50/System.Runtime.WindowsRuntime.dll": {} + } + }, + "System.Security.Claims/4.0.0": { + "type": "package", + "dependencies": { + "System.Collections": "4.0.0", + "System.Diagnostics.Debug": "4.0.0", + "System.Globalization": "4.0.0", + "System.IO": "4.0.0", + "System.Resources.ResourceManager": "4.0.0", + "System.Runtime": "4.0.20", + "System.Runtime.Extensions": "4.0.0", + "System.Security.Principal": "4.0.0" + }, + "compile": { + "ref/dotnet/System.Security.Claims.dll": {} + }, + "runtime": { + "lib/dotnet/System.Security.Claims.dll": {} + } + }, + "System.Security.Principal/4.0.0": { + "type": "package", + "dependencies": { + "System.Runtime": "4.0.0" + }, + "compile": { + "ref/netcore50/System.Security.Principal.dll": {} + }, + "runtime": { + "lib/netcore50/System.Security.Principal.dll": {} + } + }, + "System.Text.Encoding/4.0.10": { + "type": "package", + "dependencies": { + "System.Runtime": "4.0.0" + }, + "compile": { + "ref/dotnet/System.Text.Encoding.dll": {} + }, + "runtime": { + "runtimes/win8-aot/lib/netcore50/System.Text.Encoding.dll": {} + } + }, + "System.Text.Encoding.Extensions/4.0.10": { + "type": "package", + "dependencies": { + "System.Runtime": "4.0.0", + "System.Text.Encoding": "4.0.10" + }, + "compile": { + "ref/dotnet/System.Text.Encoding.Extensions.dll": {} + }, + "runtime": { + "runtimes/win8-aot/lib/netcore50/System.Text.Encoding.Extensions.dll": {} + } + }, + "System.Text.RegularExpressions/4.0.10": { + "type": "package", + "dependencies": { + "System.Collections": "4.0.10", + "System.Globalization": "4.0.10", + "System.Resources.ResourceManager": "4.0.0", + "System.Runtime": "4.0.20", + "System.Runtime.Extensions": "4.0.10", + "System.Threading": "4.0.10" + }, + "compile": { + "ref/dotnet/System.Text.RegularExpressions.dll": {} + }, + "runtime": { + "lib/dotnet/System.Text.RegularExpressions.dll": {} + } + }, + "System.Threading/4.0.10": { + "type": "package", + "dependencies": { + "System.Runtime": "4.0.0", + "System.Threading.Tasks": "4.0.0" + }, + "compile": { + "ref/dotnet/System.Threading.dll": {} + }, + "runtime": { + "runtimes/win8-aot/lib/netcore50/System.Threading.dll": {} + } + }, + "System.Threading.Overlapped/4.0.0": { + "type": "package", + "dependencies": { + "System.Resources.ResourceManager": "4.0.0", + "System.Runtime": "4.0.20", + "System.Runtime.Extensions": "4.0.0", + "System.Runtime.Handles": "4.0.0", + "System.Runtime.InteropServices": "4.0.20", + "System.Threading": "4.0.10" + }, + "compile": { + "ref/dotnet/System.Threading.Overlapped.dll": {} + }, + "runtime": { + "lib/netcore50/System.Threading.Overlapped.dll": {} + } + }, + "System.Threading.Tasks/4.0.10": { + "type": "package", + "dependencies": { + "System.Runtime": "4.0.0" + }, + "compile": { + "ref/dotnet/System.Threading.Tasks.dll": {} + }, + "runtime": { + "runtimes/win8-aot/lib/netcore50/System.Threading.Tasks.dll": {} + } + }, + "System.Threading.Tasks.Dataflow/4.5.25": { + "type": "package", + "dependencies": { + "System.Collections": "4.0.0", + "System.Collections.Concurrent": "4.0.0", + "System.Diagnostics.Debug": "4.0.0", + "System.Diagnostics.Tracing": "4.0.0", + "System.Dynamic.Runtime": "4.0.0", + "System.Linq": "4.0.0", + "System.Resources.ResourceManager": "4.0.0", + "System.Runtime": "4.0.0", + "System.Runtime.Extensions": "4.0.0", + "System.Threading": "4.0.0", + "System.Threading.Tasks": "4.0.0" + }, + "compile": { + "lib/dotnet/System.Threading.Tasks.Dataflow.dll": {} + }, + "runtime": { + "lib/dotnet/System.Threading.Tasks.Dataflow.dll": {} + } + }, + "System.Threading.Tasks.Parallel/4.0.0": { + "type": "package", + "dependencies": { + "System.Collections.Concurrent": "4.0.10", + "System.Diagnostics.Debug": "4.0.10", + "System.Diagnostics.Tracing": "4.0.20", + "System.Resources.ResourceManager": "4.0.0", + "System.Runtime": "4.0.20", + "System.Runtime.Extensions": "4.0.10", + "System.Threading": "4.0.10", + "System.Threading.Tasks": "4.0.10" + }, + "compile": { + "ref/netcore50/System.Threading.Tasks.Parallel.dll": {} + }, + "runtime": { + "lib/netcore50/System.Threading.Tasks.Parallel.dll": {} + } + }, + "System.Threading.Timer/4.0.0": { + "type": "package", + "compile": { + "ref/netcore50/System.Threading.Timer.dll": {} + }, + "runtime": { + "runtimes/win8-aot/lib/netcore50/System.Threading.Timer.dll": {} + } + }, + "System.Xml.ReaderWriter/4.0.10": { + "type": "package", + "dependencies": { + "System.Collections": "4.0.10", + "System.Diagnostics.Debug": "4.0.10", + "System.Globalization": "4.0.10", + "System.IO": "4.0.10", + "System.IO.FileSystem": "4.0.0", + "System.IO.FileSystem.Primitives": "4.0.0", + "System.Resources.ResourceManager": "4.0.0", + "System.Runtime": "4.0.20", + "System.Runtime.Extensions": "4.0.10", + "System.Runtime.InteropServices": "4.0.20", + "System.Text.Encoding": "4.0.10", + "System.Text.Encoding.Extensions": "4.0.10", + "System.Text.RegularExpressions": "4.0.10", + "System.Threading.Tasks": "4.0.10" + }, + "compile": { + "ref/dotnet/System.Xml.ReaderWriter.dll": {} + }, + "runtime": { + "lib/dotnet/System.Xml.ReaderWriter.dll": {} + } + }, + "System.Xml.XDocument/4.0.10": { + "type": "package", + "dependencies": { + "System.Collections": "4.0.10", + "System.Diagnostics.Debug": "4.0.10", + "System.Globalization": "4.0.10", + "System.IO": "4.0.10", + "System.Reflection": "4.0.10", + "System.Resources.ResourceManager": "4.0.0", + "System.Runtime": "4.0.20", + "System.Runtime.Extensions": "4.0.10", + "System.Text.Encoding": "4.0.10", + "System.Threading": "4.0.10", + "System.Xml.ReaderWriter": "4.0.10" + }, + "compile": { + "ref/dotnet/System.Xml.XDocument.dll": {} + }, + "runtime": { + "lib/dotnet/System.Xml.XDocument.dll": {} + } + } + }, + "UAP,Version=v10.0/win10-x86": { + "Microsoft.CSharp/4.0.0": { + "type": "package", + "dependencies": { + "System.Collections": "4.0.10", + "System.Diagnostics.Debug": "4.0.10", + "System.Dynamic.Runtime": "4.0.0", + "System.Globalization": "4.0.10", + "System.Linq": "4.0.0", + "System.Linq.Expressions": "4.0.0", + "System.ObjectModel": "4.0.10", + "System.Reflection": "4.0.10", + "System.Reflection.Extensions": "4.0.0", + "System.Reflection.Primitives": "4.0.0", + "System.Reflection.TypeExtensions": "4.0.0", + "System.Resources.ResourceManager": "4.0.0", + "System.Runtime": "4.0.20", + "System.Runtime.Extensions": "4.0.10", + "System.Runtime.InteropServices": "4.0.20", + "System.Threading": "4.0.10" + }, + "compile": { + "ref/netcore50/Microsoft.CSharp.dll": {} + }, + "runtime": { + "lib/netcore50/Microsoft.CSharp.dll": {} + } + }, + "Microsoft.NETCore/5.0.0": { + "type": "package", + "dependencies": { + "Microsoft.CSharp": "4.0.0", + "Microsoft.NETCore.Targets": "1.0.0", + "Microsoft.VisualBasic": "10.0.0", + "System.AppContext": "4.0.0", + "System.Collections": "4.0.10", + "System.Collections.Concurrent": "4.0.10", + "System.Collections.Immutable": "1.1.37", + "System.ComponentModel": "4.0.0", + "System.ComponentModel.Annotations": "4.0.10", + "System.Diagnostics.Debug": "4.0.10", + "System.Diagnostics.Tools": "4.0.0", + "System.Diagnostics.Tracing": "4.0.20", + "System.Dynamic.Runtime": "4.0.10", + "System.Globalization": "4.0.10", + "System.Globalization.Calendars": "4.0.0", + "System.Globalization.Extensions": "4.0.0", + "System.IO": "4.0.10", + "System.IO.Compression": "4.0.0", + "System.IO.Compression.ZipFile": "4.0.0", + "System.IO.FileSystem": "4.0.0", + "System.IO.FileSystem.Primitives": "4.0.0", + "System.IO.UnmanagedMemoryStream": "4.0.0", + "System.Linq": "4.0.0", + "System.Linq.Expressions": "4.0.10", + "System.Linq.Parallel": "4.0.0", + "System.Linq.Queryable": "4.0.0", + "System.Net.Http": "4.0.0", + "System.Net.NetworkInformation": "4.0.0", + "System.Net.Primitives": "4.0.10", + "System.Numerics.Vectors": "4.1.0", + "System.ObjectModel": "4.0.10", + "System.Reflection": "4.0.10", + "System.Reflection.DispatchProxy": "4.0.0", + "System.Reflection.Extensions": "4.0.0", + "System.Reflection.Metadata": "1.0.22", + "System.Reflection.Primitives": "4.0.0", + "System.Reflection.TypeExtensions": "4.0.0", + "System.Resources.ResourceManager": "4.0.0", + "System.Runtime": "4.0.20", + "System.Runtime.Extensions": "4.0.10", + "System.Runtime.Handles": "4.0.0", + "System.Runtime.InteropServices": "4.0.20", + "System.Runtime.Numerics": "4.0.0", + "System.Security.Claims": "4.0.0", + "System.Security.Principal": "4.0.0", + "System.Text.Encoding": "4.0.10", + "System.Text.Encoding.Extensions": "4.0.10", + "System.Text.RegularExpressions": "4.0.10", + "System.Threading": "4.0.10", + "System.Threading.Tasks": "4.0.10", + "System.Threading.Tasks.Dataflow": "4.5.25", + "System.Threading.Tasks.Parallel": "4.0.0", + "System.Threading.Timer": "4.0.0", + "System.Xml.ReaderWriter": "4.0.10", + "System.Xml.XDocument": "4.0.10" + } + }, + "Microsoft.NETCore.Platforms/1.0.0": { + "type": "package" + }, + "Microsoft.NETCore.Portable.Compatibility/1.0.0": { + "type": "package", + "dependencies": { + "Microsoft.NETCore.Runtime": "1.0.0" + }, + "compile": { + "ref/netcore50/System.ComponentModel.DataAnnotations.dll": {}, + "ref/netcore50/System.Core.dll": {}, + "ref/netcore50/System.Net.dll": {}, + "ref/netcore50/System.Numerics.dll": {}, + "ref/netcore50/System.Runtime.Serialization.dll": {}, + "ref/netcore50/System.ServiceModel.Web.dll": {}, + "ref/netcore50/System.ServiceModel.dll": {}, + "ref/netcore50/System.Windows.dll": {}, + "ref/netcore50/System.Xml.Linq.dll": {}, + "ref/netcore50/System.Xml.Serialization.dll": {}, + "ref/netcore50/System.Xml.dll": {}, + "ref/netcore50/System.dll": {}, + "ref/netcore50/mscorlib.dll": {} + }, + "runtime": { + "lib/netcore50/System.ComponentModel.DataAnnotations.dll": {}, + "lib/netcore50/System.Core.dll": {}, + "lib/netcore50/System.Net.dll": {}, + "lib/netcore50/System.Numerics.dll": {}, + "lib/netcore50/System.Runtime.Serialization.dll": {}, + "lib/netcore50/System.ServiceModel.Web.dll": {}, + "lib/netcore50/System.ServiceModel.dll": {}, + "lib/netcore50/System.Windows.dll": {}, + "lib/netcore50/System.Xml.Linq.dll": {}, + "lib/netcore50/System.Xml.Serialization.dll": {}, + "lib/netcore50/System.Xml.dll": {}, + "lib/netcore50/System.dll": {} + } + }, + "Microsoft.NETCore.Runtime/1.0.0": { + "type": "package", + "dependencies": { + "Microsoft.NETCore.Runtime.CoreCLR-x86": "1.0.0", + "Microsoft.NETCore.Windows.ApiSets-x86": "1.0.0" + } + }, + "Microsoft.NETCore.Runtime.CoreCLR-x86/1.0.0": { + "type": "package", + "dependencies": { + "System.Collections": "[4.0.10]", + "System.Diagnostics.Contracts": "[4.0.0]", + "System.Diagnostics.Debug": "[4.0.10]", + "System.Diagnostics.StackTrace": "[4.0.0]", + "System.Diagnostics.Tools": "[4.0.0]", + "System.Diagnostics.Tracing": "[4.0.20]", + "System.Globalization": "[4.0.10]", + "System.Globalization.Calendars": "[4.0.0]", + "System.IO": "[4.0.10]", + "System.ObjectModel": "[4.0.10]", + "System.Private.Uri": "[4.0.0]", + "System.Reflection": "[4.0.10]", + "System.Reflection.Extensions": "[4.0.0]", + "System.Reflection.Primitives": "[4.0.0]", + "System.Resources.ResourceManager": "[4.0.0]", + "System.Runtime": "[4.0.20]", + "System.Runtime.Extensions": "[4.0.10]", + "System.Runtime.Handles": "[4.0.0]", + "System.Runtime.InteropServices": "[4.0.20]", + "System.Text.Encoding": "[4.0.10]", + "System.Text.Encoding.Extensions": "[4.0.10]", + "System.Threading": "[4.0.10]", + "System.Threading.Tasks": "[4.0.10]", + "System.Threading.Timer": "[4.0.0]" + }, + "compile": { + "ref/dotnet/_._": {} + }, + "runtime": { + "runtimes/win7-x86/lib/dotnet/mscorlib.ni.dll": {} + }, + "native": { + "runtimes/win7-x86/native/clretwrc.dll": {}, + "runtimes/win7-x86/native/coreclr.dll": {}, + "runtimes/win7-x86/native/dbgshim.dll": {}, + "runtimes/win7-x86/native/mscordaccore.dll": {}, + "runtimes/win7-x86/native/mscordbi.dll": {}, + "runtimes/win7-x86/native/mscorrc.debug.dll": {}, + "runtimes/win7-x86/native/mscorrc.dll": {} + } + }, + "Microsoft.NETCore.Targets/1.0.0": { + "type": "package", + "dependencies": { + "Microsoft.NETCore.Platforms": "1.0.0", + "Microsoft.NETCore.Targets.UniversalWindowsPlatform": "5.0.0" + } + }, + "Microsoft.NETCore.Targets.UniversalWindowsPlatform/5.0.0": { + "type": "package" + }, + "Microsoft.NETCore.Windows.ApiSets-x86/1.0.0": { + "type": "package", + "native": { + "runtimes/win10-x86/native/_._": {} + } + }, + "Microsoft.VisualBasic/10.0.0": { + "type": "package", + "dependencies": { + "System.Collections": "4.0.10", + "System.Diagnostics.Debug": "4.0.10", + "System.Dynamic.Runtime": "4.0.10", + "System.Globalization": "4.0.10", + "System.Linq": "4.0.0", + "System.Linq.Expressions": "4.0.10", + "System.ObjectModel": "4.0.10", + "System.Reflection": "4.0.10", + "System.Reflection.Extensions": "4.0.0", + "System.Reflection.Primitives": "4.0.0", + "System.Reflection.TypeExtensions": "4.0.0", + "System.Resources.ResourceManager": "4.0.0", + "System.Runtime": "4.0.20", + "System.Runtime.Extensions": "4.0.10", + "System.Runtime.InteropServices": "4.0.20", + "System.Threading": "4.0.10" + }, + "compile": { + "ref/netcore50/Microsoft.VisualBasic.dll": {} + }, + "runtime": { + "lib/netcore50/Microsoft.VisualBasic.dll": {} + } + }, + "Microsoft.Win32.Primitives/4.0.0": { + "type": "package", + "dependencies": { + "System.Runtime": "4.0.20", + "System.Runtime.InteropServices": "4.0.20" + }, + "compile": { + "ref/dotnet/Microsoft.Win32.Primitives.dll": {} + }, + "runtime": { + "lib/dotnet/Microsoft.Win32.Primitives.dll": {} + } + }, + "System.AppContext/4.0.0": { + "type": "package", + "dependencies": { + "System.Collections": "4.0.0", + "System.Resources.ResourceManager": "4.0.0", + "System.Runtime": "4.0.20", + "System.Threading": "4.0.0" + }, + "compile": { + "ref/dotnet/System.AppContext.dll": {} + }, + "runtime": { + "lib/netcore50/System.AppContext.dll": {} + } + }, + "System.Collections/4.0.10": { + "type": "package", + "dependencies": { + "System.Diagnostics.Debug": "4.0.0", + "System.Resources.ResourceManager": "4.0.0", + "System.Runtime": "4.0.20", + "System.Runtime.Extensions": "4.0.0", + "System.Threading": "4.0.0" + }, + "compile": { + "ref/dotnet/System.Collections.dll": {} + }, + "runtime": { + "lib/netcore50/System.Collections.dll": {} + } + }, + "System.Collections.Concurrent/4.0.10": { + "type": "package", + "dependencies": { + "System.Collections": "4.0.10", + "System.Diagnostics.Debug": "4.0.10", + "System.Diagnostics.Tracing": "4.0.20", + "System.Globalization": "4.0.10", + "System.Resources.ResourceManager": "4.0.0", + "System.Runtime": "4.0.20", + "System.Runtime.Extensions": "4.0.10", + "System.Threading": "4.0.10", + "System.Threading.Tasks": "4.0.10" + }, + "compile": { + "ref/dotnet/System.Collections.Concurrent.dll": {} + }, + "runtime": { + "lib/dotnet/System.Collections.Concurrent.dll": {} + } + }, + "System.Collections.Immutable/1.1.37": { + "type": "package", + "dependencies": { + "System.Collections": "4.0.0", + "System.Diagnostics.Debug": "4.0.0", + "System.Globalization": "4.0.0", + "System.Linq": "4.0.0", + "System.Resources.ResourceManager": "4.0.0", + "System.Runtime": "4.0.0", + "System.Runtime.Extensions": "4.0.0", + "System.Threading": "4.0.0" + }, + "compile": { + "lib/dotnet/System.Collections.Immutable.dll": {} + }, + "runtime": { + "lib/dotnet/System.Collections.Immutable.dll": {} + } + }, + "System.Collections.NonGeneric/4.0.0": { + "type": "package", + "dependencies": { + "System.Diagnostics.Debug": "4.0.10", + "System.Globalization": "4.0.10", + "System.Resources.ResourceManager": "4.0.0", + "System.Runtime": "4.0.20", + "System.Runtime.Extensions": "4.0.10", + "System.Threading": "4.0.10" + }, + "compile": { + "ref/dotnet/System.Collections.NonGeneric.dll": {} + }, + "runtime": { + "lib/dotnet/System.Collections.NonGeneric.dll": {} + } + }, + "System.ComponentModel/4.0.0": { + "type": "package", + "dependencies": { + "System.Runtime": "4.0.20" + }, + "compile": { + "ref/netcore50/System.ComponentModel.dll": {} + }, + "runtime": { + "lib/netcore50/System.ComponentModel.dll": {} + } + }, + "System.ComponentModel.Annotations/4.0.10": { + "type": "package", + "dependencies": { + "System.Collections": "4.0.10", + "System.ComponentModel": "4.0.0", + "System.Globalization": "4.0.10", + "System.Linq": "4.0.0", + "System.Reflection": "4.0.10", + "System.Reflection.Extensions": "4.0.0", + "System.Resources.ResourceManager": "4.0.0", + "System.Runtime": "4.0.20", + "System.Runtime.Extensions": "4.0.10", + "System.Text.RegularExpressions": "4.0.10", + "System.Threading": "4.0.10" + }, + "compile": { + "ref/dotnet/System.ComponentModel.Annotations.dll": {} + }, + "runtime": { + "lib/dotnet/System.ComponentModel.Annotations.dll": {} + } + }, + "System.Diagnostics.Contracts/4.0.0": { + "type": "package", + "compile": { + "ref/netcore50/System.Diagnostics.Contracts.dll": {} + }, + "runtime": { + "lib/netcore50/System.Diagnostics.Contracts.dll": {} + } + }, + "System.Diagnostics.Debug/4.0.10": { + "type": "package", + "dependencies": { + "System.Runtime": "4.0.0" + }, + "compile": { + "ref/dotnet/System.Diagnostics.Debug.dll": {} + }, + "runtime": { + "lib/netcore50/System.Diagnostics.Debug.dll": {} + } + }, + "System.Diagnostics.StackTrace/4.0.0": { + "type": "package", + "dependencies": { + "System.Runtime": "4.0.20" + }, + "compile": { + "ref/dotnet/System.Diagnostics.StackTrace.dll": {} + }, + "runtime": { + "lib/netcore50/System.Diagnostics.StackTrace.dll": {} + } + }, + "System.Diagnostics.Tools/4.0.0": { + "type": "package", + "compile": { + "ref/netcore50/System.Diagnostics.Tools.dll": {} + }, + "runtime": { + "lib/netcore50/System.Diagnostics.Tools.dll": {} + } + }, + "System.Diagnostics.Tracing/4.0.20": { + "type": "package", + "dependencies": { + "System.Collections": "4.0.10", + "System.Globalization": "4.0.0", + "System.Reflection": "4.0.10", + "System.Reflection.Extensions": "4.0.0", + "System.Resources.ResourceManager": "4.0.0", + "System.Runtime": "4.0.20", + "System.Runtime.Extensions": "4.0.10", + "System.Runtime.InteropServices": "4.0.0", + "System.Text.Encoding": "4.0.0", + "System.Threading": "4.0.10" + }, + "compile": { + "ref/dotnet/System.Diagnostics.Tracing.dll": {} + }, + "runtime": { + "lib/netcore50/System.Diagnostics.Tracing.dll": {} + } + }, + "System.Dynamic.Runtime/4.0.10": { + "type": "package", + "dependencies": { + "System.Collections": "4.0.0", + "System.Diagnostics.Debug": "4.0.0", + "System.Globalization": "4.0.0", + "System.Linq": "4.0.0", + "System.Linq.Expressions": "4.0.10", + "System.ObjectModel": "4.0.0", + "System.Reflection": "4.0.0", + "System.Reflection.Emit.ILGeneration": "4.0.0", + "System.Reflection.Emit.Lightweight": "4.0.0", + "System.Reflection.TypeExtensions": "4.0.0", + "System.Resources.ResourceManager": "4.0.0", + "System.Runtime": "4.0.20", + "System.Runtime.Extensions": "4.0.0", + "System.Threading": "4.0.0" + }, + "compile": { + "ref/dotnet/System.Dynamic.Runtime.dll": {} + }, + "runtime": { + "lib/netcore50/System.Dynamic.Runtime.dll": {} + } + }, + "System.Globalization/4.0.10": { + "type": "package", + "dependencies": { + "System.Runtime": "4.0.0" + }, + "compile": { + "ref/dotnet/System.Globalization.dll": {} + }, + "runtime": { + "lib/netcore50/System.Globalization.dll": {} + } + }, + "System.Globalization.Calendars/4.0.0": { + "type": "package", + "dependencies": { + "System.Globalization": "4.0.0", + "System.Runtime": "4.0.0" + }, + "compile": { + "ref/dotnet/System.Globalization.Calendars.dll": {} + }, + "runtime": { + "lib/netcore50/System.Globalization.Calendars.dll": {} + } + }, + "System.Globalization.Extensions/4.0.0": { + "type": "package", + "dependencies": { + "System.Globalization": "4.0.10", + "System.Resources.ResourceManager": "4.0.0", + "System.Runtime": "4.0.20", + "System.Runtime.Extensions": "4.0.10", + "System.Runtime.InteropServices": "4.0.20" + }, + "compile": { + "ref/dotnet/System.Globalization.Extensions.dll": {} + }, + "runtime": { + "lib/dotnet/System.Globalization.Extensions.dll": {} + } + }, + "System.IO/4.0.10": { + "type": "package", + "dependencies": { + "System.Globalization": "4.0.0", + "System.Runtime": "4.0.20", + "System.Text.Encoding": "4.0.10", + "System.Text.Encoding.Extensions": "4.0.0", + "System.Threading": "4.0.0", + "System.Threading.Tasks": "4.0.0" + }, + "compile": { + "ref/dotnet/System.IO.dll": {} + }, + "runtime": { + "lib/netcore50/System.IO.dll": {} + } + }, + "System.IO.Compression/4.0.0": { + "type": "package", + "dependencies": { + "System.Collections": "4.0.0", + "System.IO": "4.0.0", + "System.IO.Compression.clrcompression-x86": "4.0.0", + "System.Resources.ResourceManager": "4.0.0", + "System.Runtime": "4.0.0", + "System.Runtime.Extensions": "4.0.0", + "System.Runtime.InteropServices": "4.0.0", + "System.Text.Encoding": "4.0.0", + "System.Threading": "4.0.0", + "System.Threading.Tasks": "4.0.0" + }, + "compile": { + "ref/netcore50/System.IO.Compression.dll": {} + }, + "runtime": { + "lib/netcore50/System.IO.Compression.dll": {} + } + }, + "System.IO.Compression.clrcompression-x86/4.0.0": { + "type": "package", + "native": { + "runtimes/win10-x86/native/ClrCompression.dll": {} + } + }, + "System.IO.Compression.ZipFile/4.0.0": { + "type": "package", + "dependencies": { + "System.IO": "4.0.10", + "System.IO.Compression": "4.0.0", + "System.IO.FileSystem": "4.0.0", + "System.IO.FileSystem.Primitives": "4.0.0", + "System.Resources.ResourceManager": "4.0.0", + "System.Runtime": "4.0.20", + "System.Runtime.Extensions": "4.0.10", + "System.Text.Encoding": "4.0.10" + }, + "compile": { + "ref/dotnet/System.IO.Compression.ZipFile.dll": {} + }, + "runtime": { + "lib/dotnet/System.IO.Compression.ZipFile.dll": {} + } + }, + "System.IO.FileSystem/4.0.0": { + "type": "package", + "dependencies": { + "System.Collections": "4.0.10", + "System.Diagnostics.Debug": "4.0.10", + "System.IO": "4.0.10", + "System.IO.FileSystem.Primitives": "4.0.0", + "System.Resources.ResourceManager": "4.0.0", + "System.Runtime": "4.0.20", + "System.Runtime.Extensions": "4.0.10", + "System.Runtime.Handles": "4.0.0", + "System.Runtime.InteropServices": "4.0.20", + "System.Runtime.WindowsRuntime": "4.0.0", + "System.Text.Encoding": "4.0.10", + "System.Text.Encoding.Extensions": "4.0.10", + "System.Threading": "4.0.10", + "System.Threading.Overlapped": "4.0.0", + "System.Threading.Tasks": "4.0.10" + }, + "compile": { + "ref/dotnet/System.IO.FileSystem.dll": {} + }, + "runtime": { + "lib/netcore50/System.IO.FileSystem.dll": {} + } + }, + "System.IO.FileSystem.Primitives/4.0.0": { + "type": "package", + "dependencies": { + "System.Runtime": "4.0.20" + }, + "compile": { + "ref/dotnet/System.IO.FileSystem.Primitives.dll": {} + }, + "runtime": { + "lib/dotnet/System.IO.FileSystem.Primitives.dll": {} + } + }, + "System.IO.UnmanagedMemoryStream/4.0.0": { + "type": "package", + "dependencies": { + "System.IO": "4.0.10", + "System.IO.FileSystem.Primitives": "4.0.0", + "System.Resources.ResourceManager": "4.0.0", + "System.Runtime": "4.0.20", + "System.Runtime.InteropServices": "4.0.20", + "System.Threading": "4.0.10", + "System.Threading.Tasks": "4.0.10" + }, + "compile": { + "ref/dotnet/System.IO.UnmanagedMemoryStream.dll": {} + }, + "runtime": { + "lib/dotnet/System.IO.UnmanagedMemoryStream.dll": {} + } + }, + "System.Linq/4.0.0": { + "type": "package", + "dependencies": { + "System.Collections": "4.0.10", + "System.Diagnostics.Debug": "4.0.10", + "System.Resources.ResourceManager": "4.0.0", + "System.Runtime": "4.0.20", + "System.Runtime.Extensions": "4.0.10" + }, + "compile": { + "ref/netcore50/System.Linq.dll": {} + }, + "runtime": { + "lib/netcore50/System.Linq.dll": {} + } + }, + "System.Linq.Expressions/4.0.10": { + "type": "package", + "dependencies": { + "System.Collections": "4.0.0", + "System.Diagnostics.Debug": "4.0.0", + "System.Globalization": "4.0.0", + "System.IO": "4.0.0", + "System.Linq": "4.0.0", + "System.Reflection": "4.0.0", + "System.Reflection.Emit.ILGeneration": "4.0.0", + "System.Reflection.Emit.Lightweight": "4.0.0", + "System.Reflection.Extensions": "4.0.0", + "System.Reflection.Primitives": "4.0.0", + "System.Reflection.TypeExtensions": "4.0.0", + "System.Resources.ResourceManager": "4.0.0", + "System.Runtime": "4.0.20", + "System.Runtime.Extensions": "4.0.0", + "System.Threading": "4.0.0" + }, + "compile": { + "ref/dotnet/System.Linq.Expressions.dll": {} + }, + "runtime": { + "lib/netcore50/System.Linq.Expressions.dll": {} + } + }, + "System.Linq.Parallel/4.0.0": { + "type": "package", + "dependencies": { + "System.Collections": "4.0.10", + "System.Collections.Concurrent": "4.0.10", + "System.Diagnostics.Debug": "4.0.10", + "System.Diagnostics.Tracing": "4.0.20", + "System.Linq": "4.0.0", + "System.Resources.ResourceManager": "4.0.0", + "System.Runtime": "4.0.20", + "System.Runtime.Extensions": "4.0.10", + "System.Threading": "4.0.10", + "System.Threading.Tasks": "4.0.10" + }, + "compile": { + "ref/netcore50/System.Linq.Parallel.dll": {} + }, + "runtime": { + "lib/netcore50/System.Linq.Parallel.dll": {} + } + }, + "System.Linq.Queryable/4.0.0": { + "type": "package", + "dependencies": { + "System.Collections": "4.0.10", + "System.Linq": "4.0.0", + "System.Linq.Expressions": "4.0.10", + "System.Reflection": "4.0.10", + "System.Reflection.Extensions": "4.0.0", + "System.Resources.ResourceManager": "4.0.0", + "System.Runtime": "4.0.20" + }, + "compile": { + "ref/netcore50/System.Linq.Queryable.dll": {} + }, + "runtime": { + "lib/netcore50/System.Linq.Queryable.dll": {} + } + }, + "System.Net.Http/4.0.0": { + "type": "package", + "dependencies": { + "System.Collections": "4.0.10", + "System.Diagnostics.Debug": "4.0.10", + "System.Globalization": "4.0.10", + "System.IO": "4.0.10", + "System.Net.Primitives": "4.0.0", + "System.Resources.ResourceManager": "4.0.0", + "System.Runtime": "4.0.20", + "System.Runtime.Extensions": "4.0.10", + "System.Runtime.InteropServices": "4.0.20", + "System.Runtime.WindowsRuntime": "4.0.10", + "System.Text.Encoding": "4.0.10", + "System.Text.Encoding.Extensions": "4.0.10", + "System.Threading": "4.0.10", + "System.Threading.Tasks": "4.0.10" + }, + "compile": { + "ref/netcore50/System.Net.Http.dll": {} + }, + "runtime": { + "lib/netcore50/System.Net.Http.dll": {} + } + }, + "System.Net.NetworkInformation/4.0.0": { + "type": "package", + "dependencies": { + "System.Runtime": "4.0.0", + "System.Runtime.InteropServices.WindowsRuntime": "4.0.0", + "System.Threading": "4.0.0" + }, + "compile": { + "ref/netcore50/System.Net.NetworkInformation.dll": {} + }, + "runtime": { + "lib/netcore50/System.Net.NetworkInformation.dll": {} + } + }, + "System.Net.Primitives/4.0.10": { + "type": "package", + "dependencies": { + "System.Private.Networking": "4.0.0", + "System.Runtime": "4.0.20" + }, + "compile": { + "ref/dotnet/System.Net.Primitives.dll": {} + }, + "runtime": { + "lib/netcore50/System.Net.Primitives.dll": {} + } + }, + "System.Numerics.Vectors/4.1.0": { + "type": "package", + "dependencies": { + "System.Globalization": "4.0.10", + "System.Resources.ResourceManager": "4.0.0", + "System.Runtime": "4.0.20", + "System.Runtime.Extensions": "4.0.10" + }, + "compile": { + "ref/dotnet/System.Numerics.Vectors.dll": {} + }, + "runtime": { + "lib/dotnet/System.Numerics.Vectors.dll": {} + } + }, + "System.ObjectModel/4.0.10": { + "type": "package", + "dependencies": { + "System.Collections": "4.0.10", + "System.Diagnostics.Debug": "4.0.10", + "System.Resources.ResourceManager": "4.0.0", + "System.Runtime": "4.0.20", + "System.Threading": "4.0.10" + }, + "compile": { + "ref/dotnet/System.ObjectModel.dll": {} + }, + "runtime": { + "lib/dotnet/System.ObjectModel.dll": {} + } + }, + "System.Private.Networking/4.0.0": { + "type": "package", + "dependencies": { + "Microsoft.Win32.Primitives": "4.0.0", + "System.Collections": "4.0.10", + "System.Collections.NonGeneric": "4.0.0", + "System.Diagnostics.Debug": "4.0.10", + "System.Diagnostics.Tracing": "4.0.20", + "System.Globalization": "4.0.10", + "System.IO": "4.0.10", + "System.IO.FileSystem": "4.0.0", + "System.IO.FileSystem.Primitives": "4.0.0", + "System.Resources.ResourceManager": "4.0.0", + "System.Runtime": "4.0.20", + "System.Runtime.Extensions": "4.0.10", + "System.Runtime.Handles": "4.0.0", + "System.Runtime.InteropServices": "4.0.20", + "System.Threading": "4.0.10", + "System.Threading.Overlapped": "4.0.0", + "System.Threading.Tasks": "4.0.10" + }, + "compile": { + "ref/netcore50/_._": {} + }, + "runtime": { + "lib/netcore50/System.Private.Networking.dll": {} + } + }, + "System.Private.Uri/4.0.0": { + "type": "package", + "compile": { + "ref/netcore50/_._": {} + }, + "runtime": { + "lib/netcore50/System.Private.Uri.dll": {} + } + }, + "System.Reflection/4.0.10": { + "type": "package", + "dependencies": { + "System.IO": "4.0.0", + "System.Reflection.Primitives": "4.0.0", + "System.Runtime": "4.0.20" + }, + "compile": { + "ref/dotnet/System.Reflection.dll": {} + }, + "runtime": { + "lib/netcore50/System.Reflection.dll": {} + } + }, + "System.Reflection.DispatchProxy/4.0.0": { + "type": "package", + "dependencies": { + "System.Collections": "4.0.10", + "System.Linq": "4.0.0", + "System.Reflection": "4.0.10", + "System.Reflection.Emit": "4.0.0", + "System.Reflection.Emit.ILGeneration": "4.0.0", + "System.Reflection.Extensions": "4.0.0", + "System.Reflection.Primitives": "4.0.0", + "System.Resources.ResourceManager": "4.0.0", + "System.Runtime": "4.0.20", + "System.Threading": "4.0.10" + }, + "compile": { + "ref/dotnet/System.Reflection.DispatchProxy.dll": {} + }, + "runtime": { + "lib/netcore50/System.Reflection.DispatchProxy.dll": {} + } + }, + "System.Reflection.Emit/4.0.0": { + "type": "package", + "dependencies": { + "System.IO": "4.0.0", + "System.Reflection": "4.0.0", + "System.Reflection.Emit.ILGeneration": "4.0.0", + "System.Reflection.Primitives": "4.0.0", + "System.Runtime": "4.0.0" + }, + "compile": { + "ref/dotnet/System.Reflection.Emit.dll": {} + }, + "runtime": { + "lib/netcore50/System.Reflection.Emit.dll": {} + } + }, + "System.Reflection.Emit.ILGeneration/4.0.0": { + "type": "package", + "dependencies": { + "System.Reflection": "4.0.0", + "System.Reflection.Primitives": "4.0.0", + "System.Runtime": "4.0.0" + }, + "compile": { + "ref/dotnet/System.Reflection.Emit.ILGeneration.dll": {} + }, + "runtime": { + "lib/netcore50/System.Reflection.Emit.ILGeneration.dll": {} + } + }, + "System.Reflection.Emit.Lightweight/4.0.0": { + "type": "package", + "dependencies": { + "System.Reflection": "4.0.0", + "System.Reflection.Emit.ILGeneration": "4.0.0", + "System.Reflection.Primitives": "4.0.0", + "System.Runtime": "4.0.0" + }, + "compile": { + "ref/dotnet/System.Reflection.Emit.Lightweight.dll": {} + }, + "runtime": { + "lib/netcore50/System.Reflection.Emit.Lightweight.dll": {} + } + }, + "System.Reflection.Extensions/4.0.0": { + "type": "package", + "dependencies": { + "System.Diagnostics.Debug": "4.0.10", + "System.Reflection": "4.0.10", + "System.Reflection.Primitives": "4.0.0", + "System.Reflection.TypeExtensions": "4.0.0", + "System.Resources.ResourceManager": "4.0.0", + "System.Runtime": "4.0.20", + "System.Runtime.Extensions": "4.0.10" + }, + "compile": { + "ref/netcore50/System.Reflection.Extensions.dll": {} + }, + "runtime": { + "lib/netcore50/System.Reflection.Extensions.dll": {} + } + }, + "System.Reflection.Metadata/1.0.22": { + "type": "package", + "dependencies": { + "System.Collections": "4.0.0", + "System.Collections.Immutable": "1.1.37", + "System.Diagnostics.Debug": "4.0.0", + "System.IO": "4.0.0", + "System.Reflection": "4.0.0", + "System.Reflection.Extensions": "4.0.0", + "System.Reflection.Primitives": "4.0.0", + "System.Resources.ResourceManager": "4.0.0", + "System.Runtime": "4.0.0", + "System.Runtime.Extensions": "4.0.0", + "System.Runtime.InteropServices": "4.0.0", + "System.Text.Encoding": "4.0.0", + "System.Text.Encoding.Extensions": "4.0.0", + "System.Threading": "4.0.0" + }, + "compile": { + "lib/dotnet/System.Reflection.Metadata.dll": {} + }, + "runtime": { + "lib/dotnet/System.Reflection.Metadata.dll": {} + } + }, + "System.Reflection.Primitives/4.0.0": { + "type": "package", + "dependencies": { + "System.Runtime": "4.0.0", + "System.Threading": "4.0.0" + }, + "compile": { + "ref/netcore50/System.Reflection.Primitives.dll": {} + }, + "runtime": { + "lib/netcore50/System.Reflection.Primitives.dll": {} + } + }, + "System.Reflection.TypeExtensions/4.0.0": { + "type": "package", + "dependencies": { + "System.Diagnostics.Contracts": "4.0.0", + "System.Diagnostics.Debug": "4.0.10", + "System.Linq": "4.0.0", + "System.Reflection": "4.0.10", + "System.Reflection.Primitives": "4.0.0", + "System.Resources.ResourceManager": "4.0.0", + "System.Runtime": "4.0.20", + "System.Runtime.Extensions": "4.0.10" + }, + "compile": { + "ref/dotnet/System.Reflection.TypeExtensions.dll": {} + }, + "runtime": { + "lib/netcore50/System.Reflection.TypeExtensions.dll": {} + } + }, + "System.Resources.ResourceManager/4.0.0": { + "type": "package", + "dependencies": { + "System.Globalization": "4.0.0", + "System.Reflection": "4.0.10", + "System.Runtime": "4.0.20" + }, + "compile": { + "ref/netcore50/System.Resources.ResourceManager.dll": {} + }, + "runtime": { + "lib/netcore50/System.Resources.ResourceManager.dll": {} + } + }, + "System.Runtime/4.0.20": { + "type": "package", + "dependencies": { + "System.Private.Uri": "4.0.0" + }, + "compile": { + "ref/dotnet/System.Runtime.dll": {} + }, + "runtime": { + "lib/netcore50/System.Runtime.dll": {} + } + }, + "System.Runtime.Extensions/4.0.10": { + "type": "package", + "dependencies": { + "System.Runtime": "4.0.20" + }, + "compile": { + "ref/dotnet/System.Runtime.Extensions.dll": {} + }, + "runtime": { + "lib/netcore50/System.Runtime.Extensions.dll": {} + } + }, + "System.Runtime.Handles/4.0.0": { + "type": "package", + "dependencies": { + "System.Runtime": "4.0.0" + }, + "compile": { + "ref/dotnet/System.Runtime.Handles.dll": {} + }, + "runtime": { + "lib/netcore50/System.Runtime.Handles.dll": {} + } + }, + "System.Runtime.InteropServices/4.0.20": { + "type": "package", + "dependencies": { + "System.Reflection": "4.0.0", + "System.Reflection.Primitives": "4.0.0", + "System.Runtime": "4.0.0", + "System.Runtime.Handles": "4.0.0" + }, + "compile": { + "ref/dotnet/System.Runtime.InteropServices.dll": {} + }, + "runtime": { + "lib/netcore50/System.Runtime.InteropServices.dll": {} + } + }, + "System.Runtime.InteropServices.WindowsRuntime/4.0.0": { + "type": "package", + "compile": { + "ref/netcore50/System.Runtime.InteropServices.WindowsRuntime.dll": {} + }, + "runtime": { + "lib/netcore50/System.Runtime.InteropServices.WindowsRuntime.dll": {} + } + }, + "System.Runtime.Numerics/4.0.0": { + "type": "package", + "dependencies": { + "System.Globalization": "4.0.10", + "System.Resources.ResourceManager": "4.0.0", + "System.Runtime": "4.0.20", + "System.Runtime.Extensions": "4.0.10" + }, + "compile": { + "ref/netcore50/System.Runtime.Numerics.dll": {} + }, + "runtime": { + "lib/netcore50/System.Runtime.Numerics.dll": {} + } + }, + "System.Runtime.WindowsRuntime/4.0.10": { + "type": "package", + "dependencies": { + "System.Diagnostics.Debug": "4.0.10", + "System.Globalization": "4.0.0", + "System.IO": "4.0.10", + "System.ObjectModel": "4.0.0", + "System.Resources.ResourceManager": "4.0.0", + "System.Runtime": "4.0.20", + "System.Runtime.Extensions": "4.0.0", + "System.Runtime.InteropServices": "4.0.20", + "System.Threading": "4.0.10", + "System.Threading.Tasks": "4.0.10" + }, + "compile": { + "ref/netcore50/System.Runtime.WindowsRuntime.dll": {} + }, + "runtime": { + "lib/netcore50/System.Runtime.WindowsRuntime.dll": {} + } + }, + "System.Security.Claims/4.0.0": { + "type": "package", + "dependencies": { + "System.Collections": "4.0.0", + "System.Diagnostics.Debug": "4.0.0", + "System.Globalization": "4.0.0", + "System.IO": "4.0.0", + "System.Resources.ResourceManager": "4.0.0", + "System.Runtime": "4.0.20", + "System.Runtime.Extensions": "4.0.0", + "System.Security.Principal": "4.0.0" + }, + "compile": { + "ref/dotnet/System.Security.Claims.dll": {} + }, + "runtime": { + "lib/dotnet/System.Security.Claims.dll": {} + } + }, + "System.Security.Principal/4.0.0": { + "type": "package", + "dependencies": { + "System.Runtime": "4.0.0" + }, + "compile": { + "ref/netcore50/System.Security.Principal.dll": {} + }, + "runtime": { + "lib/netcore50/System.Security.Principal.dll": {} + } + }, + "System.Text.Encoding/4.0.10": { + "type": "package", + "dependencies": { + "System.Runtime": "4.0.0" + }, + "compile": { + "ref/dotnet/System.Text.Encoding.dll": {} + }, + "runtime": { + "lib/netcore50/System.Text.Encoding.dll": {} + } + }, + "System.Text.Encoding.Extensions/4.0.10": { + "type": "package", + "dependencies": { + "System.Runtime": "4.0.0", + "System.Text.Encoding": "4.0.10" + }, + "compile": { + "ref/dotnet/System.Text.Encoding.Extensions.dll": {} + }, + "runtime": { + "lib/netcore50/System.Text.Encoding.Extensions.dll": {} + } + }, + "System.Text.RegularExpressions/4.0.10": { + "type": "package", + "dependencies": { + "System.Collections": "4.0.10", + "System.Globalization": "4.0.10", + "System.Resources.ResourceManager": "4.0.0", + "System.Runtime": "4.0.20", + "System.Runtime.Extensions": "4.0.10", + "System.Threading": "4.0.10" + }, + "compile": { + "ref/dotnet/System.Text.RegularExpressions.dll": {} + }, + "runtime": { + "lib/dotnet/System.Text.RegularExpressions.dll": {} + } + }, + "System.Threading/4.0.10": { + "type": "package", + "dependencies": { + "System.Runtime": "4.0.0", + "System.Threading.Tasks": "4.0.0" + }, + "compile": { + "ref/dotnet/System.Threading.dll": {} + }, + "runtime": { + "lib/netcore50/System.Threading.dll": {} + } + }, + "System.Threading.Overlapped/4.0.0": { + "type": "package", + "dependencies": { + "System.Resources.ResourceManager": "4.0.0", + "System.Runtime": "4.0.20", + "System.Runtime.Extensions": "4.0.0", + "System.Runtime.Handles": "4.0.0", + "System.Runtime.InteropServices": "4.0.20", + "System.Threading": "4.0.10" + }, + "compile": { + "ref/dotnet/System.Threading.Overlapped.dll": {} + }, + "runtime": { + "lib/netcore50/System.Threading.Overlapped.dll": {} + } + }, + "System.Threading.Tasks/4.0.10": { + "type": "package", + "dependencies": { + "System.Runtime": "4.0.0" + }, + "compile": { + "ref/dotnet/System.Threading.Tasks.dll": {} + }, + "runtime": { + "lib/netcore50/System.Threading.Tasks.dll": {} + } + }, + "System.Threading.Tasks.Dataflow/4.5.25": { + "type": "package", + "dependencies": { + "System.Collections": "4.0.0", + "System.Collections.Concurrent": "4.0.0", + "System.Diagnostics.Debug": "4.0.0", + "System.Diagnostics.Tracing": "4.0.0", + "System.Dynamic.Runtime": "4.0.0", + "System.Linq": "4.0.0", + "System.Resources.ResourceManager": "4.0.0", + "System.Runtime": "4.0.0", + "System.Runtime.Extensions": "4.0.0", + "System.Threading": "4.0.0", + "System.Threading.Tasks": "4.0.0" + }, + "compile": { + "lib/dotnet/System.Threading.Tasks.Dataflow.dll": {} + }, + "runtime": { + "lib/dotnet/System.Threading.Tasks.Dataflow.dll": {} + } + }, + "System.Threading.Tasks.Parallel/4.0.0": { + "type": "package", + "dependencies": { + "System.Collections.Concurrent": "4.0.10", + "System.Diagnostics.Debug": "4.0.10", + "System.Diagnostics.Tracing": "4.0.20", + "System.Resources.ResourceManager": "4.0.0", + "System.Runtime": "4.0.20", + "System.Runtime.Extensions": "4.0.10", + "System.Threading": "4.0.10", + "System.Threading.Tasks": "4.0.10" + }, + "compile": { + "ref/netcore50/System.Threading.Tasks.Parallel.dll": {} + }, + "runtime": { + "lib/netcore50/System.Threading.Tasks.Parallel.dll": {} + } + }, + "System.Threading.Timer/4.0.0": { + "type": "package", + "compile": { + "ref/netcore50/System.Threading.Timer.dll": {} + }, + "runtime": { + "lib/netcore50/System.Threading.Timer.dll": {} + } + }, + "System.Xml.ReaderWriter/4.0.10": { + "type": "package", + "dependencies": { + "System.Collections": "4.0.10", + "System.Diagnostics.Debug": "4.0.10", + "System.Globalization": "4.0.10", + "System.IO": "4.0.10", + "System.IO.FileSystem": "4.0.0", + "System.IO.FileSystem.Primitives": "4.0.0", + "System.Resources.ResourceManager": "4.0.0", + "System.Runtime": "4.0.20", + "System.Runtime.Extensions": "4.0.10", + "System.Runtime.InteropServices": "4.0.20", + "System.Text.Encoding": "4.0.10", + "System.Text.Encoding.Extensions": "4.0.10", + "System.Text.RegularExpressions": "4.0.10", + "System.Threading.Tasks": "4.0.10" + }, + "compile": { + "ref/dotnet/System.Xml.ReaderWriter.dll": {} + }, + "runtime": { + "lib/dotnet/System.Xml.ReaderWriter.dll": {} + } + }, + "System.Xml.XDocument/4.0.10": { + "type": "package", + "dependencies": { + "System.Collections": "4.0.10", + "System.Diagnostics.Debug": "4.0.10", + "System.Globalization": "4.0.10", + "System.IO": "4.0.10", + "System.Reflection": "4.0.10", + "System.Resources.ResourceManager": "4.0.0", + "System.Runtime": "4.0.20", + "System.Runtime.Extensions": "4.0.10", + "System.Text.Encoding": "4.0.10", + "System.Threading": "4.0.10", + "System.Xml.ReaderWriter": "4.0.10" + }, + "compile": { + "ref/dotnet/System.Xml.XDocument.dll": {} + }, + "runtime": { + "lib/dotnet/System.Xml.XDocument.dll": {} + } + } + }, + "UAP,Version=v10.0/win10-x86-aot": { + "Microsoft.CSharp/4.0.0": { + "type": "package", + "dependencies": { + "System.Collections": "4.0.10", + "System.Diagnostics.Debug": "4.0.10", + "System.Dynamic.Runtime": "4.0.0", + "System.Globalization": "4.0.10", + "System.Linq": "4.0.0", + "System.Linq.Expressions": "4.0.0", + "System.ObjectModel": "4.0.10", + "System.Reflection": "4.0.10", + "System.Reflection.Extensions": "4.0.0", + "System.Reflection.Primitives": "4.0.0", + "System.Reflection.TypeExtensions": "4.0.0", + "System.Resources.ResourceManager": "4.0.0", + "System.Runtime": "4.0.20", + "System.Runtime.Extensions": "4.0.10", + "System.Runtime.InteropServices": "4.0.20", + "System.Threading": "4.0.10" + }, + "compile": { + "ref/netcore50/Microsoft.CSharp.dll": {} + }, + "runtime": { + "lib/netcore50/Microsoft.CSharp.dll": {} + } + }, + "Microsoft.NETCore/5.0.0": { + "type": "package", + "dependencies": { + "Microsoft.CSharp": "4.0.0", + "Microsoft.NETCore.Targets": "1.0.0", + "Microsoft.VisualBasic": "10.0.0", + "System.AppContext": "4.0.0", + "System.Collections": "4.0.10", + "System.Collections.Concurrent": "4.0.10", + "System.Collections.Immutable": "1.1.37", + "System.ComponentModel": "4.0.0", + "System.ComponentModel.Annotations": "4.0.10", + "System.Diagnostics.Debug": "4.0.10", + "System.Diagnostics.Tools": "4.0.0", + "System.Diagnostics.Tracing": "4.0.20", + "System.Dynamic.Runtime": "4.0.10", + "System.Globalization": "4.0.10", + "System.Globalization.Calendars": "4.0.0", + "System.Globalization.Extensions": "4.0.0", + "System.IO": "4.0.10", + "System.IO.Compression": "4.0.0", + "System.IO.Compression.ZipFile": "4.0.0", + "System.IO.FileSystem": "4.0.0", + "System.IO.FileSystem.Primitives": "4.0.0", + "System.IO.UnmanagedMemoryStream": "4.0.0", + "System.Linq": "4.0.0", + "System.Linq.Expressions": "4.0.10", + "System.Linq.Parallel": "4.0.0", + "System.Linq.Queryable": "4.0.0", + "System.Net.Http": "4.0.0", + "System.Net.NetworkInformation": "4.0.0", + "System.Net.Primitives": "4.0.10", + "System.Numerics.Vectors": "4.1.0", + "System.ObjectModel": "4.0.10", + "System.Reflection": "4.0.10", + "System.Reflection.DispatchProxy": "4.0.0", + "System.Reflection.Extensions": "4.0.0", + "System.Reflection.Metadata": "1.0.22", + "System.Reflection.Primitives": "4.0.0", + "System.Reflection.TypeExtensions": "4.0.0", + "System.Resources.ResourceManager": "4.0.0", + "System.Runtime": "4.0.20", + "System.Runtime.Extensions": "4.0.10", + "System.Runtime.Handles": "4.0.0", + "System.Runtime.InteropServices": "4.0.20", + "System.Runtime.Numerics": "4.0.0", + "System.Security.Claims": "4.0.0", + "System.Security.Principal": "4.0.0", + "System.Text.Encoding": "4.0.10", + "System.Text.Encoding.Extensions": "4.0.10", + "System.Text.RegularExpressions": "4.0.10", + "System.Threading": "4.0.10", + "System.Threading.Tasks": "4.0.10", + "System.Threading.Tasks.Dataflow": "4.5.25", + "System.Threading.Tasks.Parallel": "4.0.0", + "System.Threading.Timer": "4.0.0", + "System.Xml.ReaderWriter": "4.0.10", + "System.Xml.XDocument": "4.0.10" + } + }, + "Microsoft.NETCore.Platforms/1.0.0": { + "type": "package" + }, + "Microsoft.NETCore.Portable.Compatibility/1.0.0": { + "type": "package", + "dependencies": { + "Microsoft.NETCore.Runtime": "1.0.0" + }, + "compile": { + "ref/netcore50/System.ComponentModel.DataAnnotations.dll": {}, + "ref/netcore50/System.Core.dll": {}, + "ref/netcore50/System.Net.dll": {}, + "ref/netcore50/System.Numerics.dll": {}, + "ref/netcore50/System.Runtime.Serialization.dll": {}, + "ref/netcore50/System.ServiceModel.Web.dll": {}, + "ref/netcore50/System.ServiceModel.dll": {}, + "ref/netcore50/System.Windows.dll": {}, + "ref/netcore50/System.Xml.Linq.dll": {}, + "ref/netcore50/System.Xml.Serialization.dll": {}, + "ref/netcore50/System.Xml.dll": {}, + "ref/netcore50/System.dll": {}, + "ref/netcore50/mscorlib.dll": {} + }, + "runtime": { + "runtimes/aot/lib/netcore50/System.ComponentModel.DataAnnotations.dll": {}, + "runtimes/aot/lib/netcore50/System.Core.dll": {}, + "runtimes/aot/lib/netcore50/System.Net.dll": {}, + "runtimes/aot/lib/netcore50/System.Numerics.dll": {}, + "runtimes/aot/lib/netcore50/System.Runtime.Serialization.dll": {}, + "runtimes/aot/lib/netcore50/System.ServiceModel.Web.dll": {}, + "runtimes/aot/lib/netcore50/System.ServiceModel.dll": {}, + "runtimes/aot/lib/netcore50/System.Windows.dll": {}, + "runtimes/aot/lib/netcore50/System.Xml.Linq.dll": {}, + "runtimes/aot/lib/netcore50/System.Xml.Serialization.dll": {}, + "runtimes/aot/lib/netcore50/System.Xml.dll": {}, + "runtimes/aot/lib/netcore50/System.dll": {}, + "runtimes/aot/lib/netcore50/mscorlib.dll": {} + } + }, + "Microsoft.NETCore.Runtime/1.0.0": { + "type": "package", + "dependencies": { + "Microsoft.NETCore.Runtime.Native": "1.0.0" + } + }, + "Microsoft.NETCore.Runtime.Native/1.0.0": { + "type": "package", + "dependencies": { + "System.Collections": "[4.0.10]", + "System.Diagnostics.Contracts": "[4.0.0]", + "System.Diagnostics.Debug": "[4.0.10]", + "System.Diagnostics.StackTrace": "[4.0.0]", + "System.Diagnostics.Tools": "[4.0.0]", + "System.Diagnostics.Tracing": "[4.0.20]", + "System.Globalization": "[4.0.10]", + "System.Globalization.Calendars": "[4.0.0]", + "System.IO": "[4.0.10]", + "System.ObjectModel": "[4.0.10]", + "System.Private.Uri": "[4.0.0]", + "System.Reflection": "[4.0.10]", + "System.Reflection.Extensions": "[4.0.0]", + "System.Reflection.Primitives": "[4.0.0]", + "System.Resources.ResourceManager": "[4.0.0]", + "System.Runtime": "[4.0.20]", + "System.Runtime.Extensions": "[4.0.10]", + "System.Runtime.Handles": "[4.0.0]", + "System.Runtime.InteropServices": "[4.0.20]", + "System.Text.Encoding": "[4.0.10]", + "System.Text.Encoding.Extensions": "[4.0.10]", + "System.Threading": "[4.0.10]", + "System.Threading.Tasks": "[4.0.10]", + "System.Threading.Timer": "[4.0.0]" + } + }, + "Microsoft.NETCore.Targets/1.0.0": { + "type": "package", + "dependencies": { + "Microsoft.NETCore.Platforms": "1.0.0", + "Microsoft.NETCore.Targets.UniversalWindowsPlatform": "5.0.0" + } + }, + "Microsoft.NETCore.Targets.UniversalWindowsPlatform/5.0.0": { + "type": "package" + }, + "Microsoft.VisualBasic/10.0.0": { + "type": "package", + "dependencies": { + "System.Collections": "4.0.10", + "System.Diagnostics.Debug": "4.0.10", + "System.Dynamic.Runtime": "4.0.10", + "System.Globalization": "4.0.10", + "System.Linq": "4.0.0", + "System.Linq.Expressions": "4.0.10", + "System.ObjectModel": "4.0.10", + "System.Reflection": "4.0.10", + "System.Reflection.Extensions": "4.0.0", + "System.Reflection.Primitives": "4.0.0", + "System.Reflection.TypeExtensions": "4.0.0", + "System.Resources.ResourceManager": "4.0.0", + "System.Runtime": "4.0.20", + "System.Runtime.Extensions": "4.0.10", + "System.Runtime.InteropServices": "4.0.20", + "System.Threading": "4.0.10" + }, + "compile": { + "ref/netcore50/Microsoft.VisualBasic.dll": {} + }, + "runtime": { + "lib/netcore50/Microsoft.VisualBasic.dll": {} + } + }, + "Microsoft.Win32.Primitives/4.0.0": { + "type": "package", + "dependencies": { + "System.Runtime": "4.0.20", + "System.Runtime.InteropServices": "4.0.20" + }, + "compile": { + "ref/dotnet/Microsoft.Win32.Primitives.dll": {} + }, + "runtime": { + "lib/dotnet/Microsoft.Win32.Primitives.dll": {} + } + }, + "System.AppContext/4.0.0": { + "type": "package", + "dependencies": { + "System.Collections": "4.0.0", + "System.Resources.ResourceManager": "4.0.0", + "System.Runtime": "4.0.20", + "System.Threading": "4.0.0" + }, + "compile": { + "ref/dotnet/System.AppContext.dll": {} + }, + "runtime": { + "lib/netcore50/System.AppContext.dll": {} + } + }, + "System.Collections/4.0.10": { + "type": "package", + "dependencies": { + "System.Diagnostics.Debug": "4.0.0", + "System.Resources.ResourceManager": "4.0.0", + "System.Runtime": "4.0.20", + "System.Runtime.Extensions": "4.0.0", + "System.Threading": "4.0.0" + }, + "compile": { + "ref/dotnet/System.Collections.dll": {} + }, + "runtime": { + "runtimes/win8-aot/lib/netcore50/System.Collections.dll": {} + } + }, + "System.Collections.Concurrent/4.0.10": { + "type": "package", + "dependencies": { + "System.Collections": "4.0.10", + "System.Diagnostics.Debug": "4.0.10", + "System.Diagnostics.Tracing": "4.0.20", + "System.Globalization": "4.0.10", + "System.Resources.ResourceManager": "4.0.0", + "System.Runtime": "4.0.20", + "System.Runtime.Extensions": "4.0.10", + "System.Threading": "4.0.10", + "System.Threading.Tasks": "4.0.10" + }, + "compile": { + "ref/dotnet/System.Collections.Concurrent.dll": {} + }, + "runtime": { + "lib/dotnet/System.Collections.Concurrent.dll": {} + } + }, + "System.Collections.Immutable/1.1.37": { + "type": "package", + "dependencies": { + "System.Collections": "4.0.0", + "System.Diagnostics.Debug": "4.0.0", + "System.Globalization": "4.0.0", + "System.Linq": "4.0.0", + "System.Resources.ResourceManager": "4.0.0", + "System.Runtime": "4.0.0", + "System.Runtime.Extensions": "4.0.0", + "System.Threading": "4.0.0" + }, + "compile": { + "lib/dotnet/System.Collections.Immutable.dll": {} + }, + "runtime": { + "lib/dotnet/System.Collections.Immutable.dll": {} + } + }, + "System.Collections.NonGeneric/4.0.0": { + "type": "package", + "dependencies": { + "System.Diagnostics.Debug": "4.0.10", + "System.Globalization": "4.0.10", + "System.Resources.ResourceManager": "4.0.0", + "System.Runtime": "4.0.20", + "System.Runtime.Extensions": "4.0.10", + "System.Threading": "4.0.10" + }, + "compile": { + "ref/dotnet/System.Collections.NonGeneric.dll": {} + }, + "runtime": { + "lib/dotnet/System.Collections.NonGeneric.dll": {} + } + }, + "System.ComponentModel/4.0.0": { + "type": "package", + "dependencies": { + "System.Runtime": "4.0.20" + }, + "compile": { + "ref/netcore50/System.ComponentModel.dll": {} + }, + "runtime": { + "lib/netcore50/System.ComponentModel.dll": {} + } + }, + "System.ComponentModel.Annotations/4.0.10": { + "type": "package", + "dependencies": { + "System.Collections": "4.0.10", + "System.ComponentModel": "4.0.0", + "System.Globalization": "4.0.10", + "System.Linq": "4.0.0", + "System.Reflection": "4.0.10", + "System.Reflection.Extensions": "4.0.0", + "System.Resources.ResourceManager": "4.0.0", + "System.Runtime": "4.0.20", + "System.Runtime.Extensions": "4.0.10", + "System.Text.RegularExpressions": "4.0.10", + "System.Threading": "4.0.10" + }, + "compile": { + "ref/dotnet/System.ComponentModel.Annotations.dll": {} + }, + "runtime": { + "lib/dotnet/System.ComponentModel.Annotations.dll": {} + } + }, + "System.Diagnostics.Contracts/4.0.0": { + "type": "package", + "compile": { + "ref/netcore50/System.Diagnostics.Contracts.dll": {} + }, + "runtime": { + "runtimes/win8-aot/lib/netcore50/System.Diagnostics.Contracts.dll": {} + } + }, + "System.Diagnostics.Debug/4.0.10": { + "type": "package", + "dependencies": { + "System.Runtime": "4.0.0" + }, + "compile": { + "ref/dotnet/System.Diagnostics.Debug.dll": {} + }, + "runtime": { + "runtimes/win8-aot/lib/netcore50/System.Diagnostics.Debug.dll": {} + } + }, + "System.Diagnostics.StackTrace/4.0.0": { + "type": "package", + "dependencies": { + "System.Runtime": "4.0.20" + }, + "compile": { + "ref/dotnet/System.Diagnostics.StackTrace.dll": {} + }, + "runtime": { + "runtimes/win8-aot/lib/netcore50/System.Diagnostics.StackTrace.dll": {} + } + }, + "System.Diagnostics.Tools/4.0.0": { + "type": "package", + "compile": { + "ref/netcore50/System.Diagnostics.Tools.dll": {} + }, + "runtime": { + "runtimes/win8-aot/lib/netcore50/System.Diagnostics.Tools.dll": {} + } + }, + "System.Diagnostics.Tracing/4.0.20": { + "type": "package", + "dependencies": { + "System.Collections": "4.0.10", + "System.Globalization": "4.0.0", + "System.Reflection": "4.0.10", + "System.Reflection.Extensions": "4.0.0", + "System.Resources.ResourceManager": "4.0.0", + "System.Runtime": "4.0.20", + "System.Runtime.Extensions": "4.0.10", + "System.Runtime.InteropServices": "4.0.0", + "System.Text.Encoding": "4.0.0", + "System.Threading": "4.0.10" + }, + "compile": { + "ref/dotnet/System.Diagnostics.Tracing.dll": {} + }, + "runtime": { + "runtimes/win8-aot/lib/netcore50/System.Diagnostics.Tracing.dll": {} + } + }, + "System.Dynamic.Runtime/4.0.10": { + "type": "package", + "dependencies": { + "System.Collections": "4.0.0", + "System.Diagnostics.Debug": "4.0.0", + "System.Globalization": "4.0.0", + "System.Linq": "4.0.0", + "System.Linq.Expressions": "4.0.10", + "System.ObjectModel": "4.0.0", + "System.Reflection": "4.0.0", + "System.Reflection.TypeExtensions": "4.0.0", + "System.Resources.ResourceManager": "4.0.0", + "System.Runtime": "4.0.20", + "System.Runtime.Extensions": "4.0.0", + "System.Threading": "4.0.0" + }, + "compile": { + "ref/dotnet/System.Dynamic.Runtime.dll": {} + }, + "runtime": { + "runtimes/win8-aot/lib/netcore50/System.Dynamic.Runtime.dll": {} + } + }, + "System.Globalization/4.0.10": { + "type": "package", + "dependencies": { + "System.Runtime": "4.0.0" + }, + "compile": { + "ref/dotnet/System.Globalization.dll": {} + }, + "runtime": { + "runtimes/win8-aot/lib/netcore50/System.Globalization.dll": {} + } + }, + "System.Globalization.Calendars/4.0.0": { + "type": "package", + "dependencies": { + "System.Globalization": "4.0.0", + "System.Runtime": "4.0.0" + }, + "compile": { + "ref/dotnet/System.Globalization.Calendars.dll": {} + }, + "runtime": { + "runtimes/win8-aot/lib/netcore50/System.Globalization.Calendars.dll": {} + } + }, + "System.Globalization.Extensions/4.0.0": { + "type": "package", + "dependencies": { + "System.Globalization": "4.0.10", + "System.Resources.ResourceManager": "4.0.0", + "System.Runtime": "4.0.20", + "System.Runtime.Extensions": "4.0.10", + "System.Runtime.InteropServices": "4.0.20" + }, + "compile": { + "ref/dotnet/System.Globalization.Extensions.dll": {} + }, + "runtime": { + "lib/dotnet/System.Globalization.Extensions.dll": {} + } + }, + "System.IO/4.0.10": { + "type": "package", + "dependencies": { + "System.Globalization": "4.0.0", + "System.Runtime": "4.0.20", + "System.Text.Encoding": "4.0.10", + "System.Text.Encoding.Extensions": "4.0.0", + "System.Threading": "4.0.0", + "System.Threading.Tasks": "4.0.0" + }, + "compile": { + "ref/dotnet/System.IO.dll": {} + }, + "runtime": { + "runtimes/win8-aot/lib/netcore50/System.IO.dll": {} + } + }, + "System.IO.Compression/4.0.0": { + "type": "package", + "dependencies": { + "System.Collections": "4.0.0", + "System.IO": "4.0.0", + "System.IO.Compression.clrcompression-x86": "4.0.0", + "System.Resources.ResourceManager": "4.0.0", + "System.Runtime": "4.0.0", + "System.Runtime.Extensions": "4.0.0", + "System.Runtime.InteropServices": "4.0.0", + "System.Text.Encoding": "4.0.0", + "System.Threading": "4.0.0", + "System.Threading.Tasks": "4.0.0" + }, + "compile": { + "ref/netcore50/System.IO.Compression.dll": {} + }, + "runtime": { + "lib/netcore50/System.IO.Compression.dll": {} + } + }, + "System.IO.Compression.clrcompression-x86/4.0.0": { + "type": "package", + "native": { + "runtimes/win10-x86/native/ClrCompression.dll": {} + } + }, + "System.IO.Compression.ZipFile/4.0.0": { + "type": "package", + "dependencies": { + "System.IO": "4.0.10", + "System.IO.Compression": "4.0.0", + "System.IO.FileSystem": "4.0.0", + "System.IO.FileSystem.Primitives": "4.0.0", + "System.Resources.ResourceManager": "4.0.0", + "System.Runtime": "4.0.20", + "System.Runtime.Extensions": "4.0.10", + "System.Text.Encoding": "4.0.10" + }, + "compile": { + "ref/dotnet/System.IO.Compression.ZipFile.dll": {} + }, + "runtime": { + "lib/dotnet/System.IO.Compression.ZipFile.dll": {} + } + }, + "System.IO.FileSystem/4.0.0": { + "type": "package", + "dependencies": { + "System.Collections": "4.0.10", + "System.Diagnostics.Debug": "4.0.10", + "System.IO": "4.0.10", + "System.IO.FileSystem.Primitives": "4.0.0", + "System.Resources.ResourceManager": "4.0.0", + "System.Runtime": "4.0.20", + "System.Runtime.Extensions": "4.0.10", + "System.Runtime.Handles": "4.0.0", + "System.Runtime.InteropServices": "4.0.20", + "System.Runtime.WindowsRuntime": "4.0.0", + "System.Text.Encoding": "4.0.10", + "System.Text.Encoding.Extensions": "4.0.10", + "System.Threading": "4.0.10", + "System.Threading.Overlapped": "4.0.0", + "System.Threading.Tasks": "4.0.10" + }, + "compile": { + "ref/dotnet/System.IO.FileSystem.dll": {} + }, + "runtime": { + "lib/netcore50/System.IO.FileSystem.dll": {} + } + }, + "System.IO.FileSystem.Primitives/4.0.0": { + "type": "package", + "dependencies": { + "System.Runtime": "4.0.20" + }, + "compile": { + "ref/dotnet/System.IO.FileSystem.Primitives.dll": {} + }, + "runtime": { + "lib/dotnet/System.IO.FileSystem.Primitives.dll": {} + } + }, + "System.IO.UnmanagedMemoryStream/4.0.0": { + "type": "package", + "dependencies": { + "System.IO": "4.0.10", + "System.IO.FileSystem.Primitives": "4.0.0", + "System.Resources.ResourceManager": "4.0.0", + "System.Runtime": "4.0.20", + "System.Runtime.InteropServices": "4.0.20", + "System.Threading": "4.0.10", + "System.Threading.Tasks": "4.0.10" + }, + "compile": { + "ref/dotnet/System.IO.UnmanagedMemoryStream.dll": {} + }, + "runtime": { + "lib/dotnet/System.IO.UnmanagedMemoryStream.dll": {} + } + }, + "System.Linq/4.0.0": { + "type": "package", + "dependencies": { + "System.Collections": "4.0.10", + "System.Diagnostics.Debug": "4.0.10", + "System.Resources.ResourceManager": "4.0.0", + "System.Runtime": "4.0.20", + "System.Runtime.Extensions": "4.0.10" + }, + "compile": { + "ref/netcore50/System.Linq.dll": {} + }, + "runtime": { + "lib/netcore50/System.Linq.dll": {} + } + }, + "System.Linq.Expressions/4.0.10": { + "type": "package", + "dependencies": { + "System.Collections": "4.0.0", + "System.Diagnostics.Debug": "4.0.0", + "System.Globalization": "4.0.0", + "System.IO": "4.0.0", + "System.Linq": "4.0.0", + "System.Reflection": "4.0.0", + "System.Reflection.Extensions": "4.0.0", + "System.Reflection.Primitives": "4.0.0", + "System.Reflection.TypeExtensions": "4.0.0", + "System.Resources.ResourceManager": "4.0.0", + "System.Runtime": "4.0.20", + "System.Runtime.Extensions": "4.0.0", + "System.Threading": "4.0.0" + }, + "compile": { + "ref/dotnet/System.Linq.Expressions.dll": {} + }, + "runtime": { + "runtimes/win8-aot/lib/netcore50/System.Linq.Expressions.dll": {} + } + }, + "System.Linq.Parallel/4.0.0": { + "type": "package", + "dependencies": { + "System.Collections": "4.0.10", + "System.Collections.Concurrent": "4.0.10", + "System.Diagnostics.Debug": "4.0.10", + "System.Diagnostics.Tracing": "4.0.20", + "System.Linq": "4.0.0", + "System.Resources.ResourceManager": "4.0.0", + "System.Runtime": "4.0.20", + "System.Runtime.Extensions": "4.0.10", + "System.Threading": "4.0.10", + "System.Threading.Tasks": "4.0.10" + }, + "compile": { + "ref/netcore50/System.Linq.Parallel.dll": {} + }, + "runtime": { + "lib/netcore50/System.Linq.Parallel.dll": {} + } + }, + "System.Linq.Queryable/4.0.0": { + "type": "package", + "dependencies": { + "System.Collections": "4.0.10", + "System.Linq": "4.0.0", + "System.Linq.Expressions": "4.0.10", + "System.Reflection": "4.0.10", + "System.Reflection.Extensions": "4.0.0", + "System.Resources.ResourceManager": "4.0.0", + "System.Runtime": "4.0.20" + }, + "compile": { + "ref/netcore50/System.Linq.Queryable.dll": {} + }, + "runtime": { + "lib/netcore50/System.Linq.Queryable.dll": {} + } + }, + "System.Net.Http/4.0.0": { + "type": "package", + "dependencies": { + "System.Collections": "4.0.10", + "System.Diagnostics.Debug": "4.0.10", + "System.Globalization": "4.0.10", + "System.IO": "4.0.10", + "System.Net.Primitives": "4.0.0", + "System.Resources.ResourceManager": "4.0.0", + "System.Runtime": "4.0.20", + "System.Runtime.Extensions": "4.0.10", + "System.Runtime.InteropServices": "4.0.20", + "System.Runtime.WindowsRuntime": "4.0.10", + "System.Text.Encoding": "4.0.10", + "System.Text.Encoding.Extensions": "4.0.10", + "System.Threading": "4.0.10", + "System.Threading.Tasks": "4.0.10" + }, + "compile": { + "ref/netcore50/System.Net.Http.dll": {} + }, + "runtime": { + "lib/netcore50/System.Net.Http.dll": {} + } + }, + "System.Net.NetworkInformation/4.0.0": { + "type": "package", + "dependencies": { + "System.Runtime": "4.0.0", + "System.Runtime.InteropServices.WindowsRuntime": "4.0.0", + "System.Threading": "4.0.0" + }, + "compile": { + "ref/netcore50/System.Net.NetworkInformation.dll": {} + }, + "runtime": { + "lib/netcore50/System.Net.NetworkInformation.dll": {} + } + }, + "System.Net.Primitives/4.0.10": { + "type": "package", + "dependencies": { + "System.Private.Networking": "4.0.0", + "System.Runtime": "4.0.20" + }, + "compile": { + "ref/dotnet/System.Net.Primitives.dll": {} + }, + "runtime": { + "lib/netcore50/System.Net.Primitives.dll": {} + } + }, + "System.Numerics.Vectors/4.1.0": { + "type": "package", + "dependencies": { + "System.Globalization": "4.0.10", + "System.Resources.ResourceManager": "4.0.0", + "System.Runtime": "4.0.20", + "System.Runtime.Extensions": "4.0.10" + }, + "compile": { + "ref/dotnet/System.Numerics.Vectors.dll": {} + }, + "runtime": { + "lib/dotnet/System.Numerics.Vectors.dll": {} + } + }, + "System.ObjectModel/4.0.10": { + "type": "package", + "dependencies": { + "System.Collections": "4.0.10", + "System.Diagnostics.Debug": "4.0.10", + "System.Resources.ResourceManager": "4.0.0", + "System.Runtime": "4.0.20", + "System.Threading": "4.0.10" + }, + "compile": { + "ref/dotnet/System.ObjectModel.dll": {} + }, + "runtime": { + "lib/dotnet/System.ObjectModel.dll": {} + } + }, + "System.Private.Networking/4.0.0": { + "type": "package", + "dependencies": { + "Microsoft.Win32.Primitives": "4.0.0", + "System.Collections": "4.0.10", + "System.Collections.NonGeneric": "4.0.0", + "System.Diagnostics.Debug": "4.0.10", + "System.Diagnostics.Tracing": "4.0.20", + "System.Globalization": "4.0.10", + "System.IO": "4.0.10", + "System.IO.FileSystem": "4.0.0", + "System.IO.FileSystem.Primitives": "4.0.0", + "System.Resources.ResourceManager": "4.0.0", + "System.Runtime": "4.0.20", + "System.Runtime.Extensions": "4.0.10", + "System.Runtime.Handles": "4.0.0", + "System.Runtime.InteropServices": "4.0.20", + "System.Threading": "4.0.10", + "System.Threading.Overlapped": "4.0.0", + "System.Threading.Tasks": "4.0.10" + }, + "compile": { + "ref/netcore50/_._": {} + }, + "runtime": { + "lib/netcore50/System.Private.Networking.dll": {} + } + }, + "System.Private.Uri/4.0.0": { + "type": "package", + "compile": { + "ref/netcore50/_._": {} + }, + "runtime": { + "runtimes/win8-aot/lib/netcore50/System.Private.Uri.dll": {} + } + }, + "System.Reflection/4.0.10": { + "type": "package", + "dependencies": { + "System.IO": "4.0.0", + "System.Reflection.Primitives": "4.0.0", + "System.Runtime": "4.0.20" + }, + "compile": { + "ref/dotnet/System.Reflection.dll": {} + }, + "runtime": { + "runtimes/win8-aot/lib/netcore50/System.Reflection.dll": {} + } + }, + "System.Reflection.DispatchProxy/4.0.0": { + "type": "package", + "dependencies": { + "System.Collections": "4.0.10", + "System.Linq": "4.0.0", + "System.Reflection": "4.0.10", + "System.Reflection.Extensions": "4.0.0", + "System.Reflection.Primitives": "4.0.0", + "System.Resources.ResourceManager": "4.0.0", + "System.Runtime": "4.0.20", + "System.Threading": "4.0.10" + }, + "compile": { + "ref/dotnet/System.Reflection.DispatchProxy.dll": {} + }, + "runtime": { + "runtimes/win8-aot/lib/netcore50/System.Reflection.DispatchProxy.dll": {} + } + }, + "System.Reflection.Extensions/4.0.0": { + "type": "package", + "dependencies": { + "System.Diagnostics.Debug": "4.0.10", + "System.Reflection": "4.0.10", + "System.Reflection.Primitives": "4.0.0", + "System.Reflection.TypeExtensions": "4.0.0", + "System.Resources.ResourceManager": "4.0.0", + "System.Runtime": "4.0.20", + "System.Runtime.Extensions": "4.0.10" + }, + "compile": { + "ref/netcore50/System.Reflection.Extensions.dll": {} + }, + "runtime": { + "runtimes/win8-aot/lib/netcore50/System.Reflection.Extensions.dll": {} + } + }, + "System.Reflection.Metadata/1.0.22": { + "type": "package", + "dependencies": { + "System.Collections": "4.0.0", + "System.Collections.Immutable": "1.1.37", + "System.Diagnostics.Debug": "4.0.0", + "System.IO": "4.0.0", + "System.Reflection": "4.0.0", + "System.Reflection.Extensions": "4.0.0", + "System.Reflection.Primitives": "4.0.0", + "System.Resources.ResourceManager": "4.0.0", + "System.Runtime": "4.0.0", + "System.Runtime.Extensions": "4.0.0", + "System.Runtime.InteropServices": "4.0.0", + "System.Text.Encoding": "4.0.0", + "System.Text.Encoding.Extensions": "4.0.0", + "System.Threading": "4.0.0" + }, + "compile": { + "lib/dotnet/System.Reflection.Metadata.dll": {} + }, + "runtime": { + "lib/dotnet/System.Reflection.Metadata.dll": {} + } + }, + "System.Reflection.Primitives/4.0.0": { + "type": "package", + "dependencies": { + "System.Runtime": "4.0.0", + "System.Threading": "4.0.0" + }, + "compile": { + "ref/netcore50/System.Reflection.Primitives.dll": {} + }, + "runtime": { + "runtimes/win8-aot/lib/netcore50/System.Reflection.Primitives.dll": {} + } + }, + "System.Reflection.TypeExtensions/4.0.0": { + "type": "package", + "dependencies": { + "System.Diagnostics.Contracts": "4.0.0", + "System.Diagnostics.Debug": "4.0.10", + "System.Linq": "4.0.0", + "System.Reflection": "4.0.10", + "System.Reflection.Primitives": "4.0.0", + "System.Resources.ResourceManager": "4.0.0", + "System.Runtime": "4.0.20", + "System.Runtime.Extensions": "4.0.10" + }, + "compile": { + "ref/dotnet/System.Reflection.TypeExtensions.dll": {} + }, + "runtime": { + "runtimes/win8-aot/lib/netcore50/System.Reflection.TypeExtensions.dll": {} + } + }, + "System.Resources.ResourceManager/4.0.0": { + "type": "package", + "dependencies": { + "System.Globalization": "4.0.0", + "System.Reflection": "4.0.10", + "System.Runtime": "4.0.20" + }, + "compile": { + "ref/netcore50/System.Resources.ResourceManager.dll": {} + }, + "runtime": { + "runtimes/win8-aot/lib/netcore50/System.Resources.ResourceManager.dll": {} + } + }, + "System.Runtime/4.0.20": { + "type": "package", + "dependencies": { + "System.Private.Uri": "4.0.0" + }, + "compile": { + "ref/dotnet/System.Runtime.dll": {} + }, + "runtime": { + "runtimes/win8-aot/lib/netcore50/System.Runtime.dll": {} + } + }, + "System.Runtime.Extensions/4.0.10": { + "type": "package", + "dependencies": { + "System.Runtime": "4.0.20" + }, + "compile": { + "ref/dotnet/System.Runtime.Extensions.dll": {} + }, + "runtime": { + "runtimes/win8-aot/lib/netcore50/System.Runtime.Extensions.dll": {} + } + }, + "System.Runtime.Handles/4.0.0": { + "type": "package", + "dependencies": { + "System.Runtime": "4.0.0" + }, + "compile": { + "ref/dotnet/System.Runtime.Handles.dll": {} + }, + "runtime": { + "runtimes/win8-aot/lib/netcore50/System.Runtime.Handles.dll": {} + } + }, + "System.Runtime.InteropServices/4.0.20": { + "type": "package", + "dependencies": { + "System.Reflection": "4.0.0", + "System.Reflection.Primitives": "4.0.0", + "System.Runtime": "4.0.0", + "System.Runtime.Handles": "4.0.0" + }, + "compile": { + "ref/dotnet/System.Runtime.InteropServices.dll": {} + }, + "runtime": { + "runtimes/win8-aot/lib/netcore50/System.Runtime.InteropServices.dll": {} + } + }, + "System.Runtime.InteropServices.WindowsRuntime/4.0.0": { + "type": "package", + "compile": { + "ref/netcore50/System.Runtime.InteropServices.WindowsRuntime.dll": {} + }, + "runtime": { + "runtimes/win8-aot/lib/netcore50/System.Runtime.InteropServices.WindowsRuntime.dll": {} + } + }, + "System.Runtime.Numerics/4.0.0": { + "type": "package", + "dependencies": { + "System.Globalization": "4.0.10", + "System.Resources.ResourceManager": "4.0.0", + "System.Runtime": "4.0.20", + "System.Runtime.Extensions": "4.0.10" + }, + "compile": { + "ref/netcore50/System.Runtime.Numerics.dll": {} + }, + "runtime": { + "lib/netcore50/System.Runtime.Numerics.dll": {} + } + }, + "System.Runtime.WindowsRuntime/4.0.10": { + "type": "package", + "dependencies": { + "System.Diagnostics.Debug": "4.0.10", + "System.Globalization": "4.0.0", + "System.IO": "4.0.10", + "System.ObjectModel": "4.0.0", + "System.Resources.ResourceManager": "4.0.0", + "System.Runtime": "4.0.20", + "System.Runtime.Extensions": "4.0.0", + "System.Runtime.InteropServices": "4.0.20", + "System.Threading": "4.0.10", + "System.Threading.Tasks": "4.0.10" + }, + "compile": { + "ref/netcore50/System.Runtime.WindowsRuntime.dll": {} + }, + "runtime": { + "runtimes/win8-aot/lib/netcore50/System.Runtime.WindowsRuntime.dll": {} + } + }, + "System.Security.Claims/4.0.0": { + "type": "package", + "dependencies": { + "System.Collections": "4.0.0", + "System.Diagnostics.Debug": "4.0.0", + "System.Globalization": "4.0.0", + "System.IO": "4.0.0", + "System.Resources.ResourceManager": "4.0.0", + "System.Runtime": "4.0.20", + "System.Runtime.Extensions": "4.0.0", + "System.Security.Principal": "4.0.0" + }, + "compile": { + "ref/dotnet/System.Security.Claims.dll": {} + }, + "runtime": { + "lib/dotnet/System.Security.Claims.dll": {} + } + }, + "System.Security.Principal/4.0.0": { + "type": "package", + "dependencies": { + "System.Runtime": "4.0.0" + }, + "compile": { + "ref/netcore50/System.Security.Principal.dll": {} + }, + "runtime": { + "lib/netcore50/System.Security.Principal.dll": {} + } + }, + "System.Text.Encoding/4.0.10": { + "type": "package", + "dependencies": { + "System.Runtime": "4.0.0" + }, + "compile": { + "ref/dotnet/System.Text.Encoding.dll": {} + }, + "runtime": { + "runtimes/win8-aot/lib/netcore50/System.Text.Encoding.dll": {} + } + }, + "System.Text.Encoding.Extensions/4.0.10": { + "type": "package", + "dependencies": { + "System.Runtime": "4.0.0", + "System.Text.Encoding": "4.0.10" + }, + "compile": { + "ref/dotnet/System.Text.Encoding.Extensions.dll": {} + }, + "runtime": { + "runtimes/win8-aot/lib/netcore50/System.Text.Encoding.Extensions.dll": {} + } + }, + "System.Text.RegularExpressions/4.0.10": { + "type": "package", + "dependencies": { + "System.Collections": "4.0.10", + "System.Globalization": "4.0.10", + "System.Resources.ResourceManager": "4.0.0", + "System.Runtime": "4.0.20", + "System.Runtime.Extensions": "4.0.10", + "System.Threading": "4.0.10" + }, + "compile": { + "ref/dotnet/System.Text.RegularExpressions.dll": {} + }, + "runtime": { + "lib/dotnet/System.Text.RegularExpressions.dll": {} + } + }, + "System.Threading/4.0.10": { + "type": "package", + "dependencies": { + "System.Runtime": "4.0.0", + "System.Threading.Tasks": "4.0.0" + }, + "compile": { + "ref/dotnet/System.Threading.dll": {} + }, + "runtime": { + "runtimes/win8-aot/lib/netcore50/System.Threading.dll": {} + } + }, + "System.Threading.Overlapped/4.0.0": { + "type": "package", + "dependencies": { + "System.Resources.ResourceManager": "4.0.0", + "System.Runtime": "4.0.20", + "System.Runtime.Extensions": "4.0.0", + "System.Runtime.Handles": "4.0.0", + "System.Runtime.InteropServices": "4.0.20", + "System.Threading": "4.0.10" + }, + "compile": { + "ref/dotnet/System.Threading.Overlapped.dll": {} + }, + "runtime": { + "lib/netcore50/System.Threading.Overlapped.dll": {} + } + }, + "System.Threading.Tasks/4.0.10": { + "type": "package", + "dependencies": { + "System.Runtime": "4.0.0" + }, + "compile": { + "ref/dotnet/System.Threading.Tasks.dll": {} + }, + "runtime": { + "runtimes/win8-aot/lib/netcore50/System.Threading.Tasks.dll": {} + } + }, + "System.Threading.Tasks.Dataflow/4.5.25": { + "type": "package", + "dependencies": { + "System.Collections": "4.0.0", + "System.Collections.Concurrent": "4.0.0", + "System.Diagnostics.Debug": "4.0.0", + "System.Diagnostics.Tracing": "4.0.0", + "System.Dynamic.Runtime": "4.0.0", + "System.Linq": "4.0.0", + "System.Resources.ResourceManager": "4.0.0", + "System.Runtime": "4.0.0", + "System.Runtime.Extensions": "4.0.0", + "System.Threading": "4.0.0", + "System.Threading.Tasks": "4.0.0" + }, + "compile": { + "lib/dotnet/System.Threading.Tasks.Dataflow.dll": {} + }, + "runtime": { + "lib/dotnet/System.Threading.Tasks.Dataflow.dll": {} + } + }, + "System.Threading.Tasks.Parallel/4.0.0": { + "type": "package", + "dependencies": { + "System.Collections.Concurrent": "4.0.10", + "System.Diagnostics.Debug": "4.0.10", + "System.Diagnostics.Tracing": "4.0.20", + "System.Resources.ResourceManager": "4.0.0", + "System.Runtime": "4.0.20", + "System.Runtime.Extensions": "4.0.10", + "System.Threading": "4.0.10", + "System.Threading.Tasks": "4.0.10" + }, + "compile": { + "ref/netcore50/System.Threading.Tasks.Parallel.dll": {} + }, + "runtime": { + "lib/netcore50/System.Threading.Tasks.Parallel.dll": {} + } + }, + "System.Threading.Timer/4.0.0": { + "type": "package", + "compile": { + "ref/netcore50/System.Threading.Timer.dll": {} + }, + "runtime": { + "runtimes/win8-aot/lib/netcore50/System.Threading.Timer.dll": {} + } + }, + "System.Xml.ReaderWriter/4.0.10": { + "type": "package", + "dependencies": { + "System.Collections": "4.0.10", + "System.Diagnostics.Debug": "4.0.10", + "System.Globalization": "4.0.10", + "System.IO": "4.0.10", + "System.IO.FileSystem": "4.0.0", + "System.IO.FileSystem.Primitives": "4.0.0", + "System.Resources.ResourceManager": "4.0.0", + "System.Runtime": "4.0.20", + "System.Runtime.Extensions": "4.0.10", + "System.Runtime.InteropServices": "4.0.20", + "System.Text.Encoding": "4.0.10", + "System.Text.Encoding.Extensions": "4.0.10", + "System.Text.RegularExpressions": "4.0.10", + "System.Threading.Tasks": "4.0.10" + }, + "compile": { + "ref/dotnet/System.Xml.ReaderWriter.dll": {} + }, + "runtime": { + "lib/dotnet/System.Xml.ReaderWriter.dll": {} + } + }, + "System.Xml.XDocument/4.0.10": { + "type": "package", + "dependencies": { + "System.Collections": "4.0.10", + "System.Diagnostics.Debug": "4.0.10", + "System.Globalization": "4.0.10", + "System.IO": "4.0.10", + "System.Reflection": "4.0.10", + "System.Resources.ResourceManager": "4.0.0", + "System.Runtime": "4.0.20", + "System.Runtime.Extensions": "4.0.10", + "System.Text.Encoding": "4.0.10", + "System.Threading": "4.0.10", + "System.Xml.ReaderWriter": "4.0.10" + }, + "compile": { + "ref/dotnet/System.Xml.XDocument.dll": {} + }, + "runtime": { + "lib/dotnet/System.Xml.XDocument.dll": {} + } + } + } + }, + "libraries": { + "Microsoft.CSharp/4.0.0": { + "sha512": "oWqeKUxHXdK6dL2CFjgMcaBISbkk+AqEg+yvJHE4DElNzS4QaTsCflgkkqZwVlWby1Dg9zo9n+iCAMFefFdJ/A==", + "type": "package", + "path": "Microsoft.CSharp/4.0.0", + "files": [ + "Microsoft.CSharp.4.0.0.nupkg.sha512", + "Microsoft.CSharp.nuspec", + "lib/MonoAndroid10/_._", + "lib/MonoTouch10/_._", + "lib/dotnet/Microsoft.CSharp.dll", + "lib/net45/_._", + "lib/netcore50/Microsoft.CSharp.dll", + "lib/win8/_._", + "lib/wp80/_._", + "lib/wpa81/_._", + "lib/xamarinios10/_._", + "lib/xamarinmac20/_._", + "ref/MonoAndroid10/_._", + "ref/MonoTouch10/_._", + "ref/dotnet/Microsoft.CSharp.dll", + "ref/dotnet/Microsoft.CSharp.xml", + "ref/dotnet/de/Microsoft.CSharp.xml", + "ref/dotnet/es/Microsoft.CSharp.xml", + "ref/dotnet/fr/Microsoft.CSharp.xml", + "ref/dotnet/it/Microsoft.CSharp.xml", + "ref/dotnet/ja/Microsoft.CSharp.xml", + "ref/dotnet/ko/Microsoft.CSharp.xml", + "ref/dotnet/ru/Microsoft.CSharp.xml", + "ref/dotnet/zh-hans/Microsoft.CSharp.xml", + "ref/dotnet/zh-hant/Microsoft.CSharp.xml", + "ref/net45/_._", + "ref/netcore50/Microsoft.CSharp.dll", + "ref/netcore50/Microsoft.CSharp.xml", + "ref/win8/_._", + "ref/wp80/_._", + "ref/wpa81/_._", + "ref/xamarinios10/_._", + "ref/xamarinmac20/_._" + ] + }, + "Microsoft.NETCore/5.0.0": { + "sha512": "QQMp0yYQbIdfkKhdEE6Umh2Xonau7tasG36Trw/YlHoWgYQLp7T9L+ZD8EPvdj5ubRhtOuKEKwM7HMpkagB9ZA==", + "type": "package", + "path": "Microsoft.NETCore/5.0.0", + "files": [ + "Microsoft.NETCore.5.0.0.nupkg.sha512", + "Microsoft.NETCore.nuspec", + "_._" + ] + }, + "Microsoft.NETCore.Platforms/1.0.0": { + "sha512": "0N77OwGZpXqUco2C/ynv1os7HqdFYifvNIbveLDKqL5PZaz05Rl9enCwVBjF61aumHKueLWIJ3prnmdAXxww4A==", + "type": "package", + "path": "Microsoft.NETCore.Platforms/1.0.0", + "files": [ + "Microsoft.NETCore.Platforms.1.0.0.nupkg.sha512", + "Microsoft.NETCore.Platforms.nuspec", + "runtime.json" + ] + }, + "Microsoft.NETCore.Portable.Compatibility/1.0.0": { + "sha512": "5/IFqf2zN1jzktRJitxO+5kQ+0AilcIbPvSojSJwDG3cGNSMZg44LXLB5E9RkSETE0Wh4QoALdNh1koKoF7/mA==", + "type": "package", + "path": "Microsoft.NETCore.Portable.Compatibility/1.0.0", + "files": [ + "Microsoft.NETCore.Portable.Compatibility.1.0.0.nupkg.sha512", + "Microsoft.NETCore.Portable.Compatibility.nuspec", + "lib/dnxcore50/System.ComponentModel.DataAnnotations.dll", + "lib/dnxcore50/System.Core.dll", + "lib/dnxcore50/System.Net.dll", + "lib/dnxcore50/System.Numerics.dll", + "lib/dnxcore50/System.Runtime.Serialization.dll", + "lib/dnxcore50/System.ServiceModel.Web.dll", + "lib/dnxcore50/System.ServiceModel.dll", + "lib/dnxcore50/System.Windows.dll", + "lib/dnxcore50/System.Xml.Linq.dll", + "lib/dnxcore50/System.Xml.Serialization.dll", + "lib/dnxcore50/System.Xml.dll", + "lib/dnxcore50/System.dll", + "lib/net45/_._", + "lib/netcore50/System.ComponentModel.DataAnnotations.dll", + "lib/netcore50/System.Core.dll", + "lib/netcore50/System.Net.dll", + "lib/netcore50/System.Numerics.dll", + "lib/netcore50/System.Runtime.Serialization.dll", + "lib/netcore50/System.ServiceModel.Web.dll", + "lib/netcore50/System.ServiceModel.dll", + "lib/netcore50/System.Windows.dll", + "lib/netcore50/System.Xml.Linq.dll", + "lib/netcore50/System.Xml.Serialization.dll", + "lib/netcore50/System.Xml.dll", + "lib/netcore50/System.dll", + "lib/win8/_._", + "lib/wp80/_._", + "lib/wpa81/_._", + "ref/dotnet/System.ComponentModel.DataAnnotations.dll", + "ref/dotnet/System.Core.dll", + "ref/dotnet/System.Net.dll", + "ref/dotnet/System.Numerics.dll", + "ref/dotnet/System.Runtime.Serialization.dll", + "ref/dotnet/System.ServiceModel.Web.dll", + "ref/dotnet/System.ServiceModel.dll", + "ref/dotnet/System.Windows.dll", + "ref/dotnet/System.Xml.Linq.dll", + "ref/dotnet/System.Xml.Serialization.dll", + "ref/dotnet/System.Xml.dll", + "ref/dotnet/System.dll", + "ref/dotnet/mscorlib.dll", + "ref/net45/_._", + "ref/netcore50/System.ComponentModel.DataAnnotations.dll", + "ref/netcore50/System.Core.dll", + "ref/netcore50/System.Net.dll", + "ref/netcore50/System.Numerics.dll", + "ref/netcore50/System.Runtime.Serialization.dll", + "ref/netcore50/System.ServiceModel.Web.dll", + "ref/netcore50/System.ServiceModel.dll", + "ref/netcore50/System.Windows.dll", + "ref/netcore50/System.Xml.Linq.dll", + "ref/netcore50/System.Xml.Serialization.dll", + "ref/netcore50/System.Xml.dll", + "ref/netcore50/System.dll", + "ref/netcore50/mscorlib.dll", + "ref/win8/_._", + "ref/wp80/_._", + "ref/wpa81/_._", + "runtimes/aot/lib/netcore50/System.ComponentModel.DataAnnotations.dll", + "runtimes/aot/lib/netcore50/System.Core.dll", + "runtimes/aot/lib/netcore50/System.Net.dll", + "runtimes/aot/lib/netcore50/System.Numerics.dll", + "runtimes/aot/lib/netcore50/System.Runtime.Serialization.dll", + "runtimes/aot/lib/netcore50/System.ServiceModel.Web.dll", + "runtimes/aot/lib/netcore50/System.ServiceModel.dll", + "runtimes/aot/lib/netcore50/System.Windows.dll", + "runtimes/aot/lib/netcore50/System.Xml.Linq.dll", + "runtimes/aot/lib/netcore50/System.Xml.Serialization.dll", + "runtimes/aot/lib/netcore50/System.Xml.dll", + "runtimes/aot/lib/netcore50/System.dll", + "runtimes/aot/lib/netcore50/mscorlib.dll" + ] + }, + "Microsoft.NETCore.Runtime/1.0.0": { + "sha512": "AjaMNpXLW4miEQorIqyn6iQ+BZBId6qXkhwyeh1vl6kXLqosZusbwmLNlvj/xllSQrd3aImJbvlHusam85g+xQ==", + "type": "package", + "path": "Microsoft.NETCore.Runtime/1.0.0", + "files": [ + "Microsoft.NETCore.Runtime.1.0.0.nupkg.sha512", + "Microsoft.NETCore.Runtime.nuspec", + "runtime.json" + ] + }, + "Microsoft.NETCore.Runtime.CoreCLR-arm/1.0.0": { + "sha512": "hoJfIl981eXwn9Tz8onO/J1xaYApIfp/YrhjSh9rRhml1U5Wj80LBgyp/6n+KI3VlvcAraThhnHnCTp+M3Uh+w==", + "type": "package", + "path": "Microsoft.NETCore.Runtime.CoreCLR-arm/1.0.0", + "files": [ + "Microsoft.NETCore.Runtime.CoreCLR-arm.1.0.0.nupkg.sha512", + "Microsoft.NETCore.Runtime.CoreCLR-arm.nuspec", + "ref/dotnet/_._", + "runtimes/win8-arm/lib/dotnet/mscorlib.ni.dll", + "runtimes/win8-arm/native/clretwrc.dll", + "runtimes/win8-arm/native/coreclr.dll", + "runtimes/win8-arm/native/dbgshim.dll", + "runtimes/win8-arm/native/mscordaccore.dll", + "runtimes/win8-arm/native/mscordbi.dll", + "runtimes/win8-arm/native/mscorrc.debug.dll", + "runtimes/win8-arm/native/mscorrc.dll" + ] + }, + "Microsoft.NETCore.Runtime.CoreCLR-x64/1.0.0": { + "sha512": "DaY5Z13xCZpnVIGluC5sCo4/0wy1rl6mptBH7v3RYi3guAmG88aSeFoQzyZepo0H0jEixUxNFM0+MB6Jc+j0bw==", + "type": "package", + "path": "Microsoft.NETCore.Runtime.CoreCLR-x64/1.0.0", + "files": [ + "Microsoft.NETCore.Runtime.CoreCLR-x64.1.0.0.nupkg.sha512", + "Microsoft.NETCore.Runtime.CoreCLR-x64.nuspec", + "ref/dotnet/_._", + "runtimes/win7-x64/lib/dotnet/mscorlib.ni.dll", + "runtimes/win7-x64/native/clretwrc.dll", + "runtimes/win7-x64/native/coreclr.dll", + "runtimes/win7-x64/native/dbgshim.dll", + "runtimes/win7-x64/native/mscordaccore.dll", + "runtimes/win7-x64/native/mscordbi.dll", + "runtimes/win7-x64/native/mscorrc.debug.dll", + "runtimes/win7-x64/native/mscorrc.dll" + ] + }, + "Microsoft.NETCore.Runtime.CoreCLR-x86/1.0.0": { + "sha512": "2LDffu5Is/X01GVPVuye4Wmz9/SyGDNq1Opgl5bXG3206cwNiCwsQgILOtfSWVp5mn4w401+8cjhBy3THW8HQQ==", + "type": "package", + "path": "Microsoft.NETCore.Runtime.CoreCLR-x86/1.0.0", + "files": [ + "Microsoft.NETCore.Runtime.CoreCLR-x86.1.0.0.nupkg.sha512", + "Microsoft.NETCore.Runtime.CoreCLR-x86.nuspec", + "ref/dotnet/_._", + "runtimes/win7-x86/lib/dotnet/mscorlib.ni.dll", + "runtimes/win7-x86/native/clretwrc.dll", + "runtimes/win7-x86/native/coreclr.dll", + "runtimes/win7-x86/native/dbgshim.dll", + "runtimes/win7-x86/native/mscordaccore.dll", + "runtimes/win7-x86/native/mscordbi.dll", + "runtimes/win7-x86/native/mscorrc.debug.dll", + "runtimes/win7-x86/native/mscorrc.dll" + ] + }, + "Microsoft.NETCore.Runtime.Native/1.0.0": { + "sha512": "tMsWWrH1AJCguiM22zK/vr6COxqz62Q1F02B07IXAUN405R3HGk5SkD/DL0Hte+OTjNtW9LkKXpOggGBRwYFNg==", + "type": "package", + "path": "Microsoft.NETCore.Runtime.Native/1.0.0", + "files": [ + "Microsoft.NETCore.Runtime.Native.1.0.0.nupkg.sha512", + "Microsoft.NETCore.Runtime.Native.nuspec", + "_._" + ] + }, + "Microsoft.NETCore.Targets/1.0.0": { + "sha512": "XfITpPjYLYRmAeZtb9diw6P7ylLQsSC1U2a/xj10iQpnHxkiLEBXop/psw15qMPuNca7lqgxWvzZGpQxphuXaw==", + "type": "package", + "path": "Microsoft.NETCore.Targets/1.0.0", + "files": [ + "Microsoft.NETCore.Targets.1.0.0.nupkg.sha512", + "Microsoft.NETCore.Targets.nuspec", + "runtime.json" + ] + }, + "Microsoft.NETCore.Targets.DNXCore/4.9.0": { + "sha512": "32pNFQTn/nVB15hYIztKn1Ij05ibGn8C9CfOiENbc+GbzxWWQQztDyWhS/vGzUcrFFZpcXbJ0yGHem2syNHMwQ==", + "type": "package", + "path": "Microsoft.NETCore.Targets.DNXCore/4.9.0", + "files": [ + "Microsoft.NETCore.Targets.DNXCore.4.9.0.nupkg.sha512", + "Microsoft.NETCore.Targets.DNXCore.nuspec", + "runtime.json" + ] + }, + "Microsoft.NETCore.Targets.NETFramework/4.6.0": { + "sha512": "5VA/gjJfOoohzsKYq1Qg8SY6Yc70dV3+DIQtQPYTy3fMr0brXspKTj4vb0h7l8eDt/YCVzcTloIv5sfb7Ora2g==", + "type": "package", + "path": "Microsoft.NETCore.Targets.NETFramework/4.6.0", + "files": [ + "Microsoft.NETCore.Targets.NETFramework.4.6.0.nupkg.sha512", + "Microsoft.NETCore.Targets.NETFramework.nuspec", + "runtime.json" + ] + }, + "Microsoft.NETCore.Targets.UniversalWindowsPlatform/5.0.0": { + "sha512": "jszcJ6okLlhqF4OQbhSbixLOuLUyVT3BP7Y7/i7fcDMwnHBd1Pmdz6M1Al9SMDKVLA2oSaItg4tq6C0ydv8lYQ==", + "type": "package", + "path": "Microsoft.NETCore.Targets.UniversalWindowsPlatform/5.0.0", + "files": [ + "Microsoft.NETCore.Targets.UniversalWindowsPlatform.5.0.0.nupkg.sha512", + "Microsoft.NETCore.Targets.UniversalWindowsPlatform.nuspec", + "runtime.json" + ] + }, + "Microsoft.NETCore.Windows.ApiSets-x64/1.0.0": { + "sha512": "NC+dpFMdhujz2sWAdJ8EmBk07p1zOlNi0FCCnZEbzftABpw9xZ99EMP/bUJrPTgCxHfzJAiuLPOtAauzVINk0w==", + "type": "package", + "path": "Microsoft.NETCore.Windows.ApiSets-x64/1.0.0", + "files": [ + "Microsoft.NETCore.Windows.ApiSets-x64.1.0.0.nupkg.sha512", + "Microsoft.NETCore.Windows.ApiSets-x64.nuspec", + "runtimes/win10-x64/native/_._", + "runtimes/win7-x64/native/API-MS-Win-Base-Util-L1-1-0.dll", + "runtimes/win7-x64/native/API-MS-Win-Core-Kernel32-Private-L1-1-0.dll", + "runtimes/win7-x64/native/API-MS-Win-Core-Kernel32-Private-L1-1-1.dll", + "runtimes/win7-x64/native/API-MS-Win-Core-Kernel32-Private-L1-1-2.dll", + "runtimes/win7-x64/native/API-MS-Win-Core-PrivateProfile-L1-1-0.dll", + "runtimes/win7-x64/native/API-MS-Win-Core-ProcessTopology-Obsolete-L1-1-0.dll", + "runtimes/win7-x64/native/API-MS-Win-Core-String-L2-1-0.dll", + "runtimes/win7-x64/native/API-MS-Win-Core-StringAnsi-L1-1-0.dll", + "runtimes/win7-x64/native/API-MS-Win-EventLog-Legacy-L1-1-0.dll", + "runtimes/win7-x64/native/API-MS-Win-Eventing-ClassicProvider-L1-1-0.dll", + "runtimes/win7-x64/native/API-MS-Win-Eventing-Consumer-L1-1-0.dll", + "runtimes/win7-x64/native/API-MS-Win-Eventing-Controller-L1-1-0.dll", + "runtimes/win7-x64/native/API-MS-Win-Eventing-Legacy-L1-1-0.dll", + "runtimes/win7-x64/native/API-MS-Win-Eventing-Provider-L1-1-0.dll", + "runtimes/win7-x64/native/API-MS-Win-Security-LsaPolicy-L1-1-0.dll", + "runtimes/win7-x64/native/API-MS-Win-devices-config-L1-1-0.dll", + "runtimes/win7-x64/native/API-MS-Win-devices-config-L1-1-1.dll", + "runtimes/win7-x64/native/api-ms-win-core-com-l1-1-0.dll", + "runtimes/win7-x64/native/api-ms-win-core-com-private-l1-1-0.dll", + "runtimes/win7-x64/native/api-ms-win-core-comm-l1-1-0.dll", + "runtimes/win7-x64/native/api-ms-win-core-console-l1-1-0.dll", + "runtimes/win7-x64/native/api-ms-win-core-console-l2-1-0.dll", + "runtimes/win7-x64/native/api-ms-win-core-datetime-l1-1-0.dll", + "runtimes/win7-x64/native/api-ms-win-core-datetime-l1-1-1.dll", + "runtimes/win7-x64/native/api-ms-win-core-debug-l1-1-0.dll", + "runtimes/win7-x64/native/api-ms-win-core-debug-l1-1-1.dll", + "runtimes/win7-x64/native/api-ms-win-core-delayload-l1-1-0.dll", + "runtimes/win7-x64/native/api-ms-win-core-errorhandling-l1-1-0.dll", + "runtimes/win7-x64/native/api-ms-win-core-errorhandling-l1-1-1.dll", + "runtimes/win7-x64/native/api-ms-win-core-fibers-l1-1-0.dll", + "runtimes/win7-x64/native/api-ms-win-core-fibers-l1-1-1.dll", + "runtimes/win7-x64/native/api-ms-win-core-file-l1-1-0.dll", + "runtimes/win7-x64/native/api-ms-win-core-file-l1-2-0.dll", + "runtimes/win7-x64/native/api-ms-win-core-file-l1-2-1.dll", + "runtimes/win7-x64/native/api-ms-win-core-file-l2-1-0.dll", + "runtimes/win7-x64/native/api-ms-win-core-file-l2-1-1.dll", + "runtimes/win7-x64/native/api-ms-win-core-handle-l1-1-0.dll", + "runtimes/win7-x64/native/api-ms-win-core-heap-l1-1-0.dll", + "runtimes/win7-x64/native/api-ms-win-core-heap-obsolete-l1-1-0.dll", + "runtimes/win7-x64/native/api-ms-win-core-interlocked-l1-1-0.dll", + "runtimes/win7-x64/native/api-ms-win-core-io-l1-1-0.dll", + "runtimes/win7-x64/native/api-ms-win-core-io-l1-1-1.dll", + "runtimes/win7-x64/native/api-ms-win-core-kernel32-legacy-l1-1-0.dll", + "runtimes/win7-x64/native/api-ms-win-core-kernel32-legacy-l1-1-1.dll", + "runtimes/win7-x64/native/api-ms-win-core-kernel32-legacy-l1-1-2.dll", + "runtimes/win7-x64/native/api-ms-win-core-libraryloader-l1-1-0.dll", + "runtimes/win7-x64/native/api-ms-win-core-libraryloader-l1-1-1.dll", + "runtimes/win7-x64/native/api-ms-win-core-localization-l1-2-0.dll", + "runtimes/win7-x64/native/api-ms-win-core-localization-l1-2-1.dll", + "runtimes/win7-x64/native/api-ms-win-core-localization-l2-1-0.dll", + "runtimes/win7-x64/native/api-ms-win-core-localization-obsolete-l1-2-0.dll", + "runtimes/win7-x64/native/api-ms-win-core-memory-l1-1-0.dll", + "runtimes/win7-x64/native/api-ms-win-core-memory-l1-1-1.dll", + "runtimes/win7-x64/native/api-ms-win-core-memory-l1-1-2.dll", + "runtimes/win7-x64/native/api-ms-win-core-memory-l1-1-3.dll", + "runtimes/win7-x64/native/api-ms-win-core-namedpipe-l1-1-0.dll", + "runtimes/win7-x64/native/api-ms-win-core-namedpipe-l1-2-1.dll", + "runtimes/win7-x64/native/api-ms-win-core-normalization-l1-1-0.dll", + "runtimes/win7-x64/native/api-ms-win-core-privateprofile-l1-1-1.dll", + "runtimes/win7-x64/native/api-ms-win-core-processenvironment-l1-1-0.dll", + "runtimes/win7-x64/native/api-ms-win-core-processenvironment-l1-2-0.dll", + "runtimes/win7-x64/native/api-ms-win-core-processsecurity-l1-1-0.dll", + "runtimes/win7-x64/native/api-ms-win-core-processthreads-l1-1-0.dll", + "runtimes/win7-x64/native/api-ms-win-core-processthreads-l1-1-1.dll", + "runtimes/win7-x64/native/api-ms-win-core-processthreads-l1-1-2.dll", + "runtimes/win7-x64/native/api-ms-win-core-profile-l1-1-0.dll", + "runtimes/win7-x64/native/api-ms-win-core-psapi-ansi-l1-1-0.dll", + "runtimes/win7-x64/native/api-ms-win-core-psapi-l1-1-0.dll", + "runtimes/win7-x64/native/api-ms-win-core-psapi-obsolete-l1-1-0.dll", + "runtimes/win7-x64/native/api-ms-win-core-realtime-l1-1-0.dll", + "runtimes/win7-x64/native/api-ms-win-core-registry-l1-1-0.dll", + "runtimes/win7-x64/native/api-ms-win-core-registry-l2-1-0.dll", + "runtimes/win7-x64/native/api-ms-win-core-rtlsupport-l1-1-0.dll", + "runtimes/win7-x64/native/api-ms-win-core-shlwapi-legacy-l1-1-0.dll", + "runtimes/win7-x64/native/api-ms-win-core-shlwapi-obsolete-l1-1-0.dll", + "runtimes/win7-x64/native/api-ms-win-core-shutdown-l1-1-0.dll", + "runtimes/win7-x64/native/api-ms-win-core-shutdown-l1-1-1.dll", + "runtimes/win7-x64/native/api-ms-win-core-string-l1-1-0.dll", + "runtimes/win7-x64/native/api-ms-win-core-string-obsolete-l1-1-0.dll", + "runtimes/win7-x64/native/api-ms-win-core-string-obsolete-l1-1-1.dll", + "runtimes/win7-x64/native/api-ms-win-core-stringloader-l1-1-0.dll", + "runtimes/win7-x64/native/api-ms-win-core-stringloader-l1-1-1.dll", + "runtimes/win7-x64/native/api-ms-win-core-synch-l1-1-0.dll", + "runtimes/win7-x64/native/api-ms-win-core-synch-l1-2-0.dll", + "runtimes/win7-x64/native/api-ms-win-core-sysinfo-l1-1-0.dll", + "runtimes/win7-x64/native/api-ms-win-core-sysinfo-l1-2-0.dll", + "runtimes/win7-x64/native/api-ms-win-core-sysinfo-l1-2-1.dll", + "runtimes/win7-x64/native/api-ms-win-core-sysinfo-l1-2-2.dll", + "runtimes/win7-x64/native/api-ms-win-core-sysinfo-l1-2-3.dll", + "runtimes/win7-x64/native/api-ms-win-core-threadpool-l1-2-0.dll", + "runtimes/win7-x64/native/api-ms-win-core-threadpool-legacy-l1-1-0.dll", + "runtimes/win7-x64/native/api-ms-win-core-threadpool-private-l1-1-0.dll", + "runtimes/win7-x64/native/api-ms-win-core-timezone-l1-1-0.dll", + "runtimes/win7-x64/native/api-ms-win-core-url-l1-1-0.dll", + "runtimes/win7-x64/native/api-ms-win-core-util-l1-1-0.dll", + "runtimes/win7-x64/native/api-ms-win-core-version-l1-1-0.dll", + "runtimes/win7-x64/native/api-ms-win-core-winrt-error-l1-1-0.dll", + "runtimes/win7-x64/native/api-ms-win-core-winrt-error-l1-1-1.dll", + "runtimes/win7-x64/native/api-ms-win-core-winrt-l1-1-0.dll", + "runtimes/win7-x64/native/api-ms-win-core-winrt-registration-l1-1-0.dll", + "runtimes/win7-x64/native/api-ms-win-core-winrt-robuffer-l1-1-0.dll", + "runtimes/win7-x64/native/api-ms-win-core-winrt-roparameterizediid-l1-1-0.dll", + "runtimes/win7-x64/native/api-ms-win-core-winrt-string-l1-1-0.dll", + "runtimes/win7-x64/native/api-ms-win-core-wow64-l1-1-0.dll", + "runtimes/win7-x64/native/api-ms-win-core-xstate-l1-1-0.dll", + "runtimes/win7-x64/native/api-ms-win-core-xstate-l2-1-0.dll", + "runtimes/win7-x64/native/api-ms-win-ro-typeresolution-l1-1-0.dll", + "runtimes/win7-x64/native/api-ms-win-security-base-l1-1-0.dll", + "runtimes/win7-x64/native/api-ms-win-security-cpwl-l1-1-0.dll", + "runtimes/win7-x64/native/api-ms-win-security-cryptoapi-l1-1-0.dll", + "runtimes/win7-x64/native/api-ms-win-security-lsalookup-l2-1-0.dll", + "runtimes/win7-x64/native/api-ms-win-security-lsalookup-l2-1-1.dll", + "runtimes/win7-x64/native/api-ms-win-security-provider-l1-1-0.dll", + "runtimes/win7-x64/native/api-ms-win-security-sddl-l1-1-0.dll", + "runtimes/win7-x64/native/api-ms-win-service-core-l1-1-0.dll", + "runtimes/win7-x64/native/api-ms-win-service-core-l1-1-1.dll", + "runtimes/win7-x64/native/api-ms-win-service-management-l1-1-0.dll", + "runtimes/win7-x64/native/api-ms-win-service-management-l2-1-0.dll", + "runtimes/win7-x64/native/api-ms-win-service-private-l1-1-0.dll", + "runtimes/win7-x64/native/api-ms-win-service-private-l1-1-1.dll", + "runtimes/win7-x64/native/api-ms-win-service-winsvc-l1-1-0.dll", + "runtimes/win7-x64/native/ext-ms-win-advapi32-encryptedfile-l1-1-0.dll", + "runtimes/win8-x64/native/API-MS-Win-Core-Kernel32-Private-L1-1-1.dll", + "runtimes/win8-x64/native/API-MS-Win-Core-Kernel32-Private-L1-1-2.dll", + "runtimes/win8-x64/native/API-MS-Win-devices-config-L1-1-1.dll", + "runtimes/win8-x64/native/api-ms-win-core-file-l1-2-1.dll", + "runtimes/win8-x64/native/api-ms-win-core-file-l2-1-1.dll", + "runtimes/win8-x64/native/api-ms-win-core-kernel32-legacy-l1-1-1.dll", + "runtimes/win8-x64/native/api-ms-win-core-kernel32-legacy-l1-1-2.dll", + "runtimes/win8-x64/native/api-ms-win-core-localization-l1-2-1.dll", + "runtimes/win8-x64/native/api-ms-win-core-localization-obsolete-l1-2-0.dll", + "runtimes/win8-x64/native/api-ms-win-core-memory-l1-1-2.dll", + "runtimes/win8-x64/native/api-ms-win-core-memory-l1-1-3.dll", + "runtimes/win8-x64/native/api-ms-win-core-namedpipe-l1-2-1.dll", + "runtimes/win8-x64/native/api-ms-win-core-privateprofile-l1-1-1.dll", + "runtimes/win8-x64/native/api-ms-win-core-processthreads-l1-1-2.dll", + "runtimes/win8-x64/native/api-ms-win-core-shutdown-l1-1-1.dll", + "runtimes/win8-x64/native/api-ms-win-core-string-obsolete-l1-1-1.dll", + "runtimes/win8-x64/native/api-ms-win-core-stringloader-l1-1-1.dll", + "runtimes/win8-x64/native/api-ms-win-core-sysinfo-l1-2-1.dll", + "runtimes/win8-x64/native/api-ms-win-core-sysinfo-l1-2-2.dll", + "runtimes/win8-x64/native/api-ms-win-core-sysinfo-l1-2-3.dll", + "runtimes/win8-x64/native/api-ms-win-core-winrt-error-l1-1-1.dll", + "runtimes/win8-x64/native/api-ms-win-core-xstate-l2-1-0.dll", + "runtimes/win8-x64/native/api-ms-win-security-cpwl-l1-1-0.dll", + "runtimes/win8-x64/native/api-ms-win-security-cryptoapi-l1-1-0.dll", + "runtimes/win8-x64/native/api-ms-win-security-lsalookup-l2-1-1.dll", + "runtimes/win8-x64/native/api-ms-win-service-private-l1-1-1.dll", + "runtimes/win81-x64/native/API-MS-Win-Core-Kernel32-Private-L1-1-2.dll", + "runtimes/win81-x64/native/api-ms-win-core-kernel32-legacy-l1-1-2.dll", + "runtimes/win81-x64/native/api-ms-win-core-memory-l1-1-3.dll", + "runtimes/win81-x64/native/api-ms-win-core-namedpipe-l1-2-1.dll", + "runtimes/win81-x64/native/api-ms-win-core-string-obsolete-l1-1-1.dll", + "runtimes/win81-x64/native/api-ms-win-core-sysinfo-l1-2-2.dll", + "runtimes/win81-x64/native/api-ms-win-core-sysinfo-l1-2-3.dll", + "runtimes/win81-x64/native/api-ms-win-security-cpwl-l1-1-0.dll" + ] + }, + "Microsoft.NETCore.Windows.ApiSets-x86/1.0.0": { + "sha512": "/HDRdhz5bZyhHwQ/uk/IbnDIX5VDTsHntEZYkTYo57dM+U3Ttel9/OJv0mjL64wTO/QKUJJNKp9XO+m7nSVjJQ==", + "type": "package", + "path": "Microsoft.NETCore.Windows.ApiSets-x86/1.0.0", + "files": [ + "Microsoft.NETCore.Windows.ApiSets-x86.1.0.0.nupkg.sha512", + "Microsoft.NETCore.Windows.ApiSets-x86.nuspec", + "runtimes/win10-x86/native/_._", + "runtimes/win7-x86/native/API-MS-Win-Base-Util-L1-1-0.dll", + "runtimes/win7-x86/native/API-MS-Win-Core-Kernel32-Private-L1-1-0.dll", + "runtimes/win7-x86/native/API-MS-Win-Core-Kernel32-Private-L1-1-1.dll", + "runtimes/win7-x86/native/API-MS-Win-Core-Kernel32-Private-L1-1-2.dll", + "runtimes/win7-x86/native/API-MS-Win-Core-PrivateProfile-L1-1-0.dll", + "runtimes/win7-x86/native/API-MS-Win-Core-ProcessTopology-Obsolete-L1-1-0.dll", + "runtimes/win7-x86/native/API-MS-Win-Core-String-L2-1-0.dll", + "runtimes/win7-x86/native/API-MS-Win-Core-StringAnsi-L1-1-0.dll", + "runtimes/win7-x86/native/API-MS-Win-EventLog-Legacy-L1-1-0.dll", + "runtimes/win7-x86/native/API-MS-Win-Eventing-ClassicProvider-L1-1-0.dll", + "runtimes/win7-x86/native/API-MS-Win-Eventing-Consumer-L1-1-0.dll", + "runtimes/win7-x86/native/API-MS-Win-Eventing-Controller-L1-1-0.dll", + "runtimes/win7-x86/native/API-MS-Win-Eventing-Legacy-L1-1-0.dll", + "runtimes/win7-x86/native/API-MS-Win-Eventing-Provider-L1-1-0.dll", + "runtimes/win7-x86/native/API-MS-Win-Security-LsaPolicy-L1-1-0.dll", + "runtimes/win7-x86/native/API-MS-Win-devices-config-L1-1-0.dll", + "runtimes/win7-x86/native/API-MS-Win-devices-config-L1-1-1.dll", + "runtimes/win7-x86/native/api-ms-win-core-com-l1-1-0.dll", + "runtimes/win7-x86/native/api-ms-win-core-com-private-l1-1-0.dll", + "runtimes/win7-x86/native/api-ms-win-core-comm-l1-1-0.dll", + "runtimes/win7-x86/native/api-ms-win-core-console-l1-1-0.dll", + "runtimes/win7-x86/native/api-ms-win-core-console-l2-1-0.dll", + "runtimes/win7-x86/native/api-ms-win-core-datetime-l1-1-0.dll", + "runtimes/win7-x86/native/api-ms-win-core-datetime-l1-1-1.dll", + "runtimes/win7-x86/native/api-ms-win-core-debug-l1-1-0.dll", + "runtimes/win7-x86/native/api-ms-win-core-debug-l1-1-1.dll", + "runtimes/win7-x86/native/api-ms-win-core-delayload-l1-1-0.dll", + "runtimes/win7-x86/native/api-ms-win-core-errorhandling-l1-1-0.dll", + "runtimes/win7-x86/native/api-ms-win-core-errorhandling-l1-1-1.dll", + "runtimes/win7-x86/native/api-ms-win-core-fibers-l1-1-0.dll", + "runtimes/win7-x86/native/api-ms-win-core-fibers-l1-1-1.dll", + "runtimes/win7-x86/native/api-ms-win-core-file-l1-1-0.dll", + "runtimes/win7-x86/native/api-ms-win-core-file-l1-2-0.dll", + "runtimes/win7-x86/native/api-ms-win-core-file-l1-2-1.dll", + "runtimes/win7-x86/native/api-ms-win-core-file-l2-1-0.dll", + "runtimes/win7-x86/native/api-ms-win-core-file-l2-1-1.dll", + "runtimes/win7-x86/native/api-ms-win-core-handle-l1-1-0.dll", + "runtimes/win7-x86/native/api-ms-win-core-heap-l1-1-0.dll", + "runtimes/win7-x86/native/api-ms-win-core-heap-obsolete-l1-1-0.dll", + "runtimes/win7-x86/native/api-ms-win-core-interlocked-l1-1-0.dll", + "runtimes/win7-x86/native/api-ms-win-core-io-l1-1-0.dll", + "runtimes/win7-x86/native/api-ms-win-core-io-l1-1-1.dll", + "runtimes/win7-x86/native/api-ms-win-core-kernel32-legacy-l1-1-0.dll", + "runtimes/win7-x86/native/api-ms-win-core-kernel32-legacy-l1-1-1.dll", + "runtimes/win7-x86/native/api-ms-win-core-kernel32-legacy-l1-1-2.dll", + "runtimes/win7-x86/native/api-ms-win-core-libraryloader-l1-1-0.dll", + "runtimes/win7-x86/native/api-ms-win-core-libraryloader-l1-1-1.dll", + "runtimes/win7-x86/native/api-ms-win-core-localization-l1-2-0.dll", + "runtimes/win7-x86/native/api-ms-win-core-localization-l1-2-1.dll", + "runtimes/win7-x86/native/api-ms-win-core-localization-l2-1-0.dll", + "runtimes/win7-x86/native/api-ms-win-core-localization-obsolete-l1-2-0.dll", + "runtimes/win7-x86/native/api-ms-win-core-memory-l1-1-0.dll", + "runtimes/win7-x86/native/api-ms-win-core-memory-l1-1-1.dll", + "runtimes/win7-x86/native/api-ms-win-core-memory-l1-1-2.dll", + "runtimes/win7-x86/native/api-ms-win-core-memory-l1-1-3.dll", + "runtimes/win7-x86/native/api-ms-win-core-namedpipe-l1-1-0.dll", + "runtimes/win7-x86/native/api-ms-win-core-namedpipe-l1-2-1.dll", + "runtimes/win7-x86/native/api-ms-win-core-normalization-l1-1-0.dll", + "runtimes/win7-x86/native/api-ms-win-core-privateprofile-l1-1-1.dll", + "runtimes/win7-x86/native/api-ms-win-core-processenvironment-l1-1-0.dll", + "runtimes/win7-x86/native/api-ms-win-core-processenvironment-l1-2-0.dll", + "runtimes/win7-x86/native/api-ms-win-core-processsecurity-l1-1-0.dll", + "runtimes/win7-x86/native/api-ms-win-core-processthreads-l1-1-0.dll", + "runtimes/win7-x86/native/api-ms-win-core-processthreads-l1-1-1.dll", + "runtimes/win7-x86/native/api-ms-win-core-processthreads-l1-1-2.dll", + "runtimes/win7-x86/native/api-ms-win-core-profile-l1-1-0.dll", + "runtimes/win7-x86/native/api-ms-win-core-psapi-ansi-l1-1-0.dll", + "runtimes/win7-x86/native/api-ms-win-core-psapi-l1-1-0.dll", + "runtimes/win7-x86/native/api-ms-win-core-psapi-obsolete-l1-1-0.dll", + "runtimes/win7-x86/native/api-ms-win-core-realtime-l1-1-0.dll", + "runtimes/win7-x86/native/api-ms-win-core-registry-l1-1-0.dll", + "runtimes/win7-x86/native/api-ms-win-core-registry-l2-1-0.dll", + "runtimes/win7-x86/native/api-ms-win-core-rtlsupport-l1-1-0.dll", + "runtimes/win7-x86/native/api-ms-win-core-shlwapi-legacy-l1-1-0.dll", + "runtimes/win7-x86/native/api-ms-win-core-shlwapi-obsolete-l1-1-0.dll", + "runtimes/win7-x86/native/api-ms-win-core-shutdown-l1-1-0.dll", + "runtimes/win7-x86/native/api-ms-win-core-shutdown-l1-1-1.dll", + "runtimes/win7-x86/native/api-ms-win-core-string-l1-1-0.dll", + "runtimes/win7-x86/native/api-ms-win-core-string-obsolete-l1-1-0.dll", + "runtimes/win7-x86/native/api-ms-win-core-string-obsolete-l1-1-1.dll", + "runtimes/win7-x86/native/api-ms-win-core-stringloader-l1-1-0.dll", + "runtimes/win7-x86/native/api-ms-win-core-stringloader-l1-1-1.dll", + "runtimes/win7-x86/native/api-ms-win-core-synch-l1-1-0.dll", + "runtimes/win7-x86/native/api-ms-win-core-synch-l1-2-0.dll", + "runtimes/win7-x86/native/api-ms-win-core-sysinfo-l1-1-0.dll", + "runtimes/win7-x86/native/api-ms-win-core-sysinfo-l1-2-0.dll", + "runtimes/win7-x86/native/api-ms-win-core-sysinfo-l1-2-1.dll", + "runtimes/win7-x86/native/api-ms-win-core-sysinfo-l1-2-2.dll", + "runtimes/win7-x86/native/api-ms-win-core-sysinfo-l1-2-3.dll", + "runtimes/win7-x86/native/api-ms-win-core-threadpool-l1-2-0.dll", + "runtimes/win7-x86/native/api-ms-win-core-threadpool-legacy-l1-1-0.dll", + "runtimes/win7-x86/native/api-ms-win-core-threadpool-private-l1-1-0.dll", + "runtimes/win7-x86/native/api-ms-win-core-timezone-l1-1-0.dll", + "runtimes/win7-x86/native/api-ms-win-core-url-l1-1-0.dll", + "runtimes/win7-x86/native/api-ms-win-core-util-l1-1-0.dll", + "runtimes/win7-x86/native/api-ms-win-core-version-l1-1-0.dll", + "runtimes/win7-x86/native/api-ms-win-core-winrt-error-l1-1-0.dll", + "runtimes/win7-x86/native/api-ms-win-core-winrt-error-l1-1-1.dll", + "runtimes/win7-x86/native/api-ms-win-core-winrt-l1-1-0.dll", + "runtimes/win7-x86/native/api-ms-win-core-winrt-registration-l1-1-0.dll", + "runtimes/win7-x86/native/api-ms-win-core-winrt-robuffer-l1-1-0.dll", + "runtimes/win7-x86/native/api-ms-win-core-winrt-roparameterizediid-l1-1-0.dll", + "runtimes/win7-x86/native/api-ms-win-core-winrt-string-l1-1-0.dll", + "runtimes/win7-x86/native/api-ms-win-core-wow64-l1-1-0.dll", + "runtimes/win7-x86/native/api-ms-win-core-xstate-l1-1-0.dll", + "runtimes/win7-x86/native/api-ms-win-core-xstate-l2-1-0.dll", + "runtimes/win7-x86/native/api-ms-win-ro-typeresolution-l1-1-0.dll", + "runtimes/win7-x86/native/api-ms-win-security-base-l1-1-0.dll", + "runtimes/win7-x86/native/api-ms-win-security-cpwl-l1-1-0.dll", + "runtimes/win7-x86/native/api-ms-win-security-cryptoapi-l1-1-0.dll", + "runtimes/win7-x86/native/api-ms-win-security-lsalookup-l2-1-0.dll", + "runtimes/win7-x86/native/api-ms-win-security-lsalookup-l2-1-1.dll", + "runtimes/win7-x86/native/api-ms-win-security-provider-l1-1-0.dll", + "runtimes/win7-x86/native/api-ms-win-security-sddl-l1-1-0.dll", + "runtimes/win7-x86/native/api-ms-win-service-core-l1-1-0.dll", + "runtimes/win7-x86/native/api-ms-win-service-core-l1-1-1.dll", + "runtimes/win7-x86/native/api-ms-win-service-management-l1-1-0.dll", + "runtimes/win7-x86/native/api-ms-win-service-management-l2-1-0.dll", + "runtimes/win7-x86/native/api-ms-win-service-private-l1-1-0.dll", + "runtimes/win7-x86/native/api-ms-win-service-private-l1-1-1.dll", + "runtimes/win7-x86/native/api-ms-win-service-winsvc-l1-1-0.dll", + "runtimes/win7-x86/native/ext-ms-win-advapi32-encryptedfile-l1-1-0.dll", + "runtimes/win8-x86/native/API-MS-Win-Core-Kernel32-Private-L1-1-1.dll", + "runtimes/win8-x86/native/API-MS-Win-Core-Kernel32-Private-L1-1-2.dll", + "runtimes/win8-x86/native/API-MS-Win-devices-config-L1-1-1.dll", + "runtimes/win8-x86/native/api-ms-win-core-file-l1-2-1.dll", + "runtimes/win8-x86/native/api-ms-win-core-file-l2-1-1.dll", + "runtimes/win8-x86/native/api-ms-win-core-kernel32-legacy-l1-1-1.dll", + "runtimes/win8-x86/native/api-ms-win-core-kernel32-legacy-l1-1-2.dll", + "runtimes/win8-x86/native/api-ms-win-core-localization-l1-2-1.dll", + "runtimes/win8-x86/native/api-ms-win-core-localization-obsolete-l1-2-0.dll", + "runtimes/win8-x86/native/api-ms-win-core-memory-l1-1-2.dll", + "runtimes/win8-x86/native/api-ms-win-core-memory-l1-1-3.dll", + "runtimes/win8-x86/native/api-ms-win-core-namedpipe-l1-2-1.dll", + "runtimes/win8-x86/native/api-ms-win-core-privateprofile-l1-1-1.dll", + "runtimes/win8-x86/native/api-ms-win-core-processthreads-l1-1-2.dll", + "runtimes/win8-x86/native/api-ms-win-core-shutdown-l1-1-1.dll", + "runtimes/win8-x86/native/api-ms-win-core-string-obsolete-l1-1-1.dll", + "runtimes/win8-x86/native/api-ms-win-core-stringloader-l1-1-1.dll", + "runtimes/win8-x86/native/api-ms-win-core-sysinfo-l1-2-1.dll", + "runtimes/win8-x86/native/api-ms-win-core-sysinfo-l1-2-2.dll", + "runtimes/win8-x86/native/api-ms-win-core-sysinfo-l1-2-3.dll", + "runtimes/win8-x86/native/api-ms-win-core-winrt-error-l1-1-1.dll", + "runtimes/win8-x86/native/api-ms-win-core-xstate-l2-1-0.dll", + "runtimes/win8-x86/native/api-ms-win-security-cpwl-l1-1-0.dll", + "runtimes/win8-x86/native/api-ms-win-security-cryptoapi-l1-1-0.dll", + "runtimes/win8-x86/native/api-ms-win-security-lsalookup-l2-1-1.dll", + "runtimes/win8-x86/native/api-ms-win-service-private-l1-1-1.dll", + "runtimes/win81-x86/native/API-MS-Win-Core-Kernel32-Private-L1-1-2.dll", + "runtimes/win81-x86/native/api-ms-win-core-kernel32-legacy-l1-1-2.dll", + "runtimes/win81-x86/native/api-ms-win-core-memory-l1-1-3.dll", + "runtimes/win81-x86/native/api-ms-win-core-namedpipe-l1-2-1.dll", + "runtimes/win81-x86/native/api-ms-win-core-string-obsolete-l1-1-1.dll", + "runtimes/win81-x86/native/api-ms-win-core-sysinfo-l1-2-2.dll", + "runtimes/win81-x86/native/api-ms-win-core-sysinfo-l1-2-3.dll", + "runtimes/win81-x86/native/api-ms-win-security-cpwl-l1-1-0.dll" + ] + }, + "Microsoft.VisualBasic/10.0.0": { + "sha512": "5BEm2/HAVd97whRlCChU7rmSh/9cwGlZ/NTNe3Jl07zuPWfKQq5TUvVNUmdvmEe8QRecJLZ4/e7WF1i1O8V42g==", + "type": "package", + "path": "Microsoft.VisualBasic/10.0.0", + "files": [ + "Microsoft.VisualBasic.10.0.0.nupkg.sha512", + "Microsoft.VisualBasic.nuspec", + "lib/dotnet/Microsoft.VisualBasic.dll", + "lib/net45/_._", + "lib/netcore50/Microsoft.VisualBasic.dll", + "lib/win8/_._", + "lib/wpa81/_._", + "ref/dotnet/Microsoft.VisualBasic.dll", + "ref/dotnet/Microsoft.VisualBasic.xml", + "ref/dotnet/de/Microsoft.VisualBasic.xml", + "ref/dotnet/es/Microsoft.VisualBasic.xml", + "ref/dotnet/fr/Microsoft.VisualBasic.xml", + "ref/dotnet/it/Microsoft.VisualBasic.xml", + "ref/dotnet/ja/Microsoft.VisualBasic.xml", + "ref/dotnet/ko/Microsoft.VisualBasic.xml", + "ref/dotnet/ru/Microsoft.VisualBasic.xml", + "ref/dotnet/zh-hans/Microsoft.VisualBasic.xml", + "ref/dotnet/zh-hant/Microsoft.VisualBasic.xml", + "ref/net45/_._", + "ref/netcore50/Microsoft.VisualBasic.dll", + "ref/netcore50/Microsoft.VisualBasic.xml", + "ref/win8/_._", + "ref/wpa81/_._" + ] + }, + "Microsoft.Win32.Primitives/4.0.0": { + "sha512": "CypEz9/lLOup8CEhiAmvr7aLs1zKPYyEU1sxQeEr6G0Ci8/F0Y6pYR1zzkROjM8j8Mq0typmbu676oYyvErQvg==", + "type": "package", + "path": "Microsoft.Win32.Primitives/4.0.0", + "files": [ + "Microsoft.Win32.Primitives.4.0.0.nupkg.sha512", + "Microsoft.Win32.Primitives.nuspec", + "lib/MonoAndroid10/_._", + "lib/MonoTouch10/_._", + "lib/dotnet/Microsoft.Win32.Primitives.dll", + "lib/net46/Microsoft.Win32.Primitives.dll", + "lib/xamarinios10/_._", + "lib/xamarinmac20/_._", + "ref/MonoAndroid10/_._", + "ref/MonoTouch10/_._", + "ref/dotnet/Microsoft.Win32.Primitives.dll", + "ref/dotnet/Microsoft.Win32.Primitives.xml", + "ref/dotnet/de/Microsoft.Win32.Primitives.xml", + "ref/dotnet/es/Microsoft.Win32.Primitives.xml", + "ref/dotnet/fr/Microsoft.Win32.Primitives.xml", + "ref/dotnet/it/Microsoft.Win32.Primitives.xml", + "ref/dotnet/ja/Microsoft.Win32.Primitives.xml", + "ref/dotnet/ko/Microsoft.Win32.Primitives.xml", + "ref/dotnet/ru/Microsoft.Win32.Primitives.xml", + "ref/dotnet/zh-hans/Microsoft.Win32.Primitives.xml", + "ref/dotnet/zh-hant/Microsoft.Win32.Primitives.xml", + "ref/net46/Microsoft.Win32.Primitives.dll", + "ref/xamarinios10/_._", + "ref/xamarinmac20/_._" + ] + }, + "System.AppContext/4.0.0": { + "sha512": "gUoYgAWDC3+xhKeU5KSLbYDhTdBYk9GssrMSCcWUADzOglW+s0AmwVhOUGt2tL5xUl7ZXoYTPdA88zCgKrlG0A==", + "type": "package", + "path": "System.AppContext/4.0.0", + "files": [ + "System.AppContext.4.0.0.nupkg.sha512", + "System.AppContext.nuspec", + "lib/DNXCore50/System.AppContext.dll", + "lib/MonoAndroid10/_._", + "lib/MonoTouch10/_._", + "lib/net46/System.AppContext.dll", + "lib/netcore50/System.AppContext.dll", + "lib/xamarinios10/_._", + "lib/xamarinmac20/_._", + "ref/MonoAndroid10/_._", + "ref/MonoTouch10/_._", + "ref/dotnet/System.AppContext.dll", + "ref/dotnet/System.AppContext.xml", + "ref/dotnet/de/System.AppContext.xml", + "ref/dotnet/es/System.AppContext.xml", + "ref/dotnet/fr/System.AppContext.xml", + "ref/dotnet/it/System.AppContext.xml", + "ref/dotnet/ja/System.AppContext.xml", + "ref/dotnet/ko/System.AppContext.xml", + "ref/dotnet/ru/System.AppContext.xml", + "ref/dotnet/zh-hans/System.AppContext.xml", + "ref/dotnet/zh-hant/System.AppContext.xml", + "ref/net46/System.AppContext.dll", + "ref/xamarinios10/_._", + "ref/xamarinmac20/_._" + ] + }, + "System.Collections/4.0.10": { + "sha512": "ux6ilcZZjV/Gp7JEZpe+2V1eTueq6NuoGRM3eZCFuPM25hLVVgCRuea6STW8hvqreIOE59irJk5/ovpA5xQipw==", + "type": "package", + "path": "System.Collections/4.0.10", + "files": [ + "System.Collections.4.0.10.nupkg.sha512", + "System.Collections.nuspec", + "lib/DNXCore50/System.Collections.dll", + "lib/MonoAndroid10/_._", + "lib/MonoTouch10/_._", + "lib/net46/_._", + "lib/netcore50/System.Collections.dll", + "lib/xamarinios10/_._", + "lib/xamarinmac20/_._", + "ref/MonoAndroid10/_._", + "ref/MonoTouch10/_._", + "ref/dotnet/System.Collections.dll", + "ref/dotnet/System.Collections.xml", + "ref/dotnet/de/System.Collections.xml", + "ref/dotnet/es/System.Collections.xml", + "ref/dotnet/fr/System.Collections.xml", + "ref/dotnet/it/System.Collections.xml", + "ref/dotnet/ja/System.Collections.xml", + "ref/dotnet/ko/System.Collections.xml", + "ref/dotnet/ru/System.Collections.xml", + "ref/dotnet/zh-hans/System.Collections.xml", + "ref/dotnet/zh-hant/System.Collections.xml", + "ref/net46/_._", + "ref/xamarinios10/_._", + "ref/xamarinmac20/_._", + "runtimes/win8-aot/lib/netcore50/System.Collections.dll" + ] + }, + "System.Collections.Concurrent/4.0.10": { + "sha512": "ZtMEqOPAjAIqR8fqom9AOKRaB94a+emO2O8uOP6vyJoNswSPrbiwN7iH53rrVpvjMVx0wr4/OMpI7486uGZjbw==", + "type": "package", + "path": "System.Collections.Concurrent/4.0.10", + "files": [ + "System.Collections.Concurrent.4.0.10.nupkg.sha512", + "System.Collections.Concurrent.nuspec", + "lib/MonoAndroid10/_._", + "lib/MonoTouch10/_._", + "lib/dotnet/System.Collections.Concurrent.dll", + "lib/net46/_._", + "lib/xamarinios10/_._", + "lib/xamarinmac20/_._", + "ref/MonoAndroid10/_._", + "ref/MonoTouch10/_._", + "ref/dotnet/System.Collections.Concurrent.dll", + "ref/dotnet/System.Collections.Concurrent.xml", + "ref/dotnet/de/System.Collections.Concurrent.xml", + "ref/dotnet/es/System.Collections.Concurrent.xml", + "ref/dotnet/fr/System.Collections.Concurrent.xml", + "ref/dotnet/it/System.Collections.Concurrent.xml", + "ref/dotnet/ja/System.Collections.Concurrent.xml", + "ref/dotnet/ko/System.Collections.Concurrent.xml", + "ref/dotnet/ru/System.Collections.Concurrent.xml", + "ref/dotnet/zh-hans/System.Collections.Concurrent.xml", + "ref/dotnet/zh-hant/System.Collections.Concurrent.xml", + "ref/net46/_._", + "ref/xamarinios10/_._", + "ref/xamarinmac20/_._" + ] + }, + "System.Collections.Immutable/1.1.37": { + "sha512": "fTpqwZYBzoklTT+XjTRK8KxvmrGkYHzBiylCcKyQcxiOM8k+QvhNBxRvFHDWzy4OEP5f8/9n+xQ9mEgEXY+muA==", + "type": "package", + "path": "System.Collections.Immutable/1.1.37", + "files": [ + "System.Collections.Immutable.1.1.37.nupkg.sha512", + "System.Collections.Immutable.nuspec", + "lib/dotnet/System.Collections.Immutable.dll", + "lib/dotnet/System.Collections.Immutable.xml", + "lib/portable-net45+win8+wp8+wpa81/System.Collections.Immutable.dll", + "lib/portable-net45+win8+wp8+wpa81/System.Collections.Immutable.xml" + ] + }, + "System.Collections.NonGeneric/4.0.0": { + "sha512": "rVgwrFBMkmp8LI6GhAYd6Bx+2uLIXjRfNg6Ie+ASfX8ESuh9e2HNxFy2yh1MPIXZq3OAYa+0mmULVwpnEC6UDA==", + "type": "package", + "path": "System.Collections.NonGeneric/4.0.0", + "files": [ + "System.Collections.NonGeneric.4.0.0.nupkg.sha512", + "System.Collections.NonGeneric.nuspec", + "lib/MonoAndroid10/_._", + "lib/MonoTouch10/_._", + "lib/dotnet/System.Collections.NonGeneric.dll", + "lib/net46/System.Collections.NonGeneric.dll", + "lib/xamarinios10/_._", + "lib/xamarinmac20/_._", + "ref/MonoAndroid10/_._", + "ref/MonoTouch10/_._", + "ref/dotnet/System.Collections.NonGeneric.dll", + "ref/dotnet/System.Collections.NonGeneric.xml", + "ref/dotnet/de/System.Collections.NonGeneric.xml", + "ref/dotnet/es/System.Collections.NonGeneric.xml", + "ref/dotnet/fr/System.Collections.NonGeneric.xml", + "ref/dotnet/it/System.Collections.NonGeneric.xml", + "ref/dotnet/ja/System.Collections.NonGeneric.xml", + "ref/dotnet/ko/System.Collections.NonGeneric.xml", + "ref/dotnet/ru/System.Collections.NonGeneric.xml", + "ref/dotnet/zh-hans/System.Collections.NonGeneric.xml", + "ref/dotnet/zh-hant/System.Collections.NonGeneric.xml", + "ref/net46/System.Collections.NonGeneric.dll", + "ref/xamarinios10/_._", + "ref/xamarinmac20/_._" + ] + }, + "System.ComponentModel/4.0.0": { + "sha512": "BzpLdSi++ld7rJLOOt5f/G9GxujP202bBgKORsHcGV36rLB0mfSA2h8chTMoBzFhgN7TE14TmJ2J7Q1RyNCTAw==", + "type": "package", + "path": "System.ComponentModel/4.0.0", + "files": [ + "System.ComponentModel.4.0.0.nupkg.sha512", + "System.ComponentModel.nuspec", + "lib/dotnet/System.ComponentModel.dll", + "lib/net45/_._", + "lib/netcore50/System.ComponentModel.dll", + "lib/win8/_._", + "lib/wp80/_._", + "lib/wpa81/_._", + "ref/dotnet/System.ComponentModel.dll", + "ref/dotnet/System.ComponentModel.xml", + "ref/dotnet/de/System.ComponentModel.xml", + "ref/dotnet/es/System.ComponentModel.xml", + "ref/dotnet/fr/System.ComponentModel.xml", + "ref/dotnet/it/System.ComponentModel.xml", + "ref/dotnet/ja/System.ComponentModel.xml", + "ref/dotnet/ko/System.ComponentModel.xml", + "ref/dotnet/ru/System.ComponentModel.xml", + "ref/dotnet/zh-hans/System.ComponentModel.xml", + "ref/dotnet/zh-hant/System.ComponentModel.xml", + "ref/net45/_._", + "ref/netcore50/System.ComponentModel.dll", + "ref/netcore50/System.ComponentModel.xml", + "ref/win8/_._", + "ref/wp80/_._", + "ref/wpa81/_._" + ] + }, + "System.ComponentModel.Annotations/4.0.10": { + "sha512": "7+XGyEZx24nP1kpHxCB9e+c6D0fdVDvFwE1xujE9BzlXyNVcy5J5aIO0H/ECupx21QpyRvzZibGAHfL/XLL6dw==", + "type": "package", + "path": "System.ComponentModel.Annotations/4.0.10", + "files": [ + "System.ComponentModel.Annotations.4.0.10.nupkg.sha512", + "System.ComponentModel.Annotations.nuspec", + "lib/MonoAndroid10/_._", + "lib/MonoTouch10/_._", + "lib/dotnet/System.ComponentModel.Annotations.dll", + "lib/net46/_._", + "lib/xamarinios10/_._", + "lib/xamarinmac20/_._", + "ref/MonoAndroid10/_._", + "ref/MonoTouch10/_._", + "ref/dotnet/System.ComponentModel.Annotations.dll", + "ref/dotnet/System.ComponentModel.Annotations.xml", + "ref/dotnet/de/System.ComponentModel.Annotations.xml", + "ref/dotnet/es/System.ComponentModel.Annotations.xml", + "ref/dotnet/fr/System.ComponentModel.Annotations.xml", + "ref/dotnet/it/System.ComponentModel.Annotations.xml", + "ref/dotnet/ja/System.ComponentModel.Annotations.xml", + "ref/dotnet/ko/System.ComponentModel.Annotations.xml", + "ref/dotnet/ru/System.ComponentModel.Annotations.xml", + "ref/dotnet/zh-hans/System.ComponentModel.Annotations.xml", + "ref/dotnet/zh-hant/System.ComponentModel.Annotations.xml", + "ref/net46/_._", + "ref/xamarinios10/_._", + "ref/xamarinmac20/_._" + ] + }, + "System.ComponentModel.EventBasedAsync/4.0.10": { + "sha512": "d6kXcHUgP0jSPXEQ6hXJYCO6CzfoCi7t9vR3BfjSQLrj4HzpuATpx1gkN7itmTW1O+wjuw6rai4378Nj6N70yw==", + "type": "package", + "path": "System.ComponentModel.EventBasedAsync/4.0.10", + "files": [ + "System.ComponentModel.EventBasedAsync.4.0.10.nupkg.sha512", + "System.ComponentModel.EventBasedAsync.nuspec", + "lib/MonoAndroid10/_._", + "lib/MonoTouch10/_._", + "lib/dotnet/System.ComponentModel.EventBasedAsync.dll", + "lib/net46/_._", + "lib/xamarinios10/_._", + "lib/xamarinmac20/_._", + "ref/MonoAndroid10/_._", + "ref/MonoTouch10/_._", + "ref/dotnet/System.ComponentModel.EventBasedAsync.dll", + "ref/dotnet/System.ComponentModel.EventBasedAsync.xml", + "ref/dotnet/de/System.ComponentModel.EventBasedAsync.xml", + "ref/dotnet/es/System.ComponentModel.EventBasedAsync.xml", + "ref/dotnet/fr/System.ComponentModel.EventBasedAsync.xml", + "ref/dotnet/it/System.ComponentModel.EventBasedAsync.xml", + "ref/dotnet/ja/System.ComponentModel.EventBasedAsync.xml", + "ref/dotnet/ko/System.ComponentModel.EventBasedAsync.xml", + "ref/dotnet/ru/System.ComponentModel.EventBasedAsync.xml", + "ref/dotnet/zh-hans/System.ComponentModel.EventBasedAsync.xml", + "ref/dotnet/zh-hant/System.ComponentModel.EventBasedAsync.xml", + "ref/net46/_._", + "ref/xamarinios10/_._", + "ref/xamarinmac20/_._" + ] + }, + "System.Diagnostics.Contracts/4.0.0": { + "sha512": "lMc7HNmyIsu0pKTdA4wf+FMq5jvouUd+oUpV4BdtyqoV0Pkbg9u/7lTKFGqpjZRQosWHq1+B32Lch2wf4AmloA==", + "type": "package", + "path": "System.Diagnostics.Contracts/4.0.0", + "files": [ + "System.Diagnostics.Contracts.4.0.0.nupkg.sha512", + "System.Diagnostics.Contracts.nuspec", + "lib/DNXCore50/System.Diagnostics.Contracts.dll", + "lib/net45/_._", + "lib/netcore50/System.Diagnostics.Contracts.dll", + "lib/win8/_._", + "lib/wp80/_._", + "lib/wpa81/_._", + "ref/dotnet/System.Diagnostics.Contracts.dll", + "ref/dotnet/System.Diagnostics.Contracts.xml", + "ref/dotnet/de/System.Diagnostics.Contracts.xml", + "ref/dotnet/es/System.Diagnostics.Contracts.xml", + "ref/dotnet/fr/System.Diagnostics.Contracts.xml", + "ref/dotnet/it/System.Diagnostics.Contracts.xml", + "ref/dotnet/ja/System.Diagnostics.Contracts.xml", + "ref/dotnet/ko/System.Diagnostics.Contracts.xml", + "ref/dotnet/ru/System.Diagnostics.Contracts.xml", + "ref/dotnet/zh-hans/System.Diagnostics.Contracts.xml", + "ref/dotnet/zh-hant/System.Diagnostics.Contracts.xml", + "ref/net45/_._", + "ref/netcore50/System.Diagnostics.Contracts.dll", + "ref/netcore50/System.Diagnostics.Contracts.xml", + "ref/win8/_._", + "ref/wp80/_._", + "ref/wpa81/_._", + "runtimes/win8-aot/lib/netcore50/System.Diagnostics.Contracts.dll" + ] + }, + "System.Diagnostics.Debug/4.0.10": { + "sha512": "pi2KthuvI2LWV2c2V+fwReDsDiKpNl040h6DcwFOb59SafsPT/V1fCy0z66OKwysurJkBMmp5j5CBe3Um+ub0g==", + "type": "package", + "path": "System.Diagnostics.Debug/4.0.10", + "files": [ + "System.Diagnostics.Debug.4.0.10.nupkg.sha512", + "System.Diagnostics.Debug.nuspec", + "lib/DNXCore50/System.Diagnostics.Debug.dll", + "lib/MonoAndroid10/_._", + "lib/MonoTouch10/_._", + "lib/net46/_._", + "lib/netcore50/System.Diagnostics.Debug.dll", + "lib/xamarinios10/_._", + "lib/xamarinmac20/_._", + "ref/MonoAndroid10/_._", + "ref/MonoTouch10/_._", + "ref/dotnet/System.Diagnostics.Debug.dll", + "ref/dotnet/System.Diagnostics.Debug.xml", + "ref/dotnet/de/System.Diagnostics.Debug.xml", + "ref/dotnet/es/System.Diagnostics.Debug.xml", + "ref/dotnet/fr/System.Diagnostics.Debug.xml", + "ref/dotnet/it/System.Diagnostics.Debug.xml", + "ref/dotnet/ja/System.Diagnostics.Debug.xml", + "ref/dotnet/ko/System.Diagnostics.Debug.xml", + "ref/dotnet/ru/System.Diagnostics.Debug.xml", + "ref/dotnet/zh-hans/System.Diagnostics.Debug.xml", + "ref/dotnet/zh-hant/System.Diagnostics.Debug.xml", + "ref/net46/_._", + "ref/xamarinios10/_._", + "ref/xamarinmac20/_._", + "runtimes/win8-aot/lib/netcore50/System.Diagnostics.Debug.dll" + ] + }, + "System.Diagnostics.StackTrace/4.0.0": { + "sha512": "PItgenqpRiMqErvQONBlfDwctKpWVrcDSW5pppNZPJ6Bpiyz+KjsWoSiaqs5dt03HEbBTMNCrZb8KCkh7YfXmw==", + "type": "package", + "path": "System.Diagnostics.StackTrace/4.0.0", + "files": [ + "System.Diagnostics.StackTrace.4.0.0.nupkg.sha512", + "System.Diagnostics.StackTrace.nuspec", + "lib/DNXCore50/System.Diagnostics.StackTrace.dll", + "lib/MonoAndroid10/_._", + "lib/MonoTouch10/_._", + "lib/net46/System.Diagnostics.StackTrace.dll", + "lib/netcore50/System.Diagnostics.StackTrace.dll", + "lib/xamarinios10/_._", + "lib/xamarinmac20/_._", + "ref/MonoAndroid10/_._", + "ref/MonoTouch10/_._", + "ref/dotnet/System.Diagnostics.StackTrace.dll", + "ref/dotnet/System.Diagnostics.StackTrace.xml", + "ref/dotnet/de/System.Diagnostics.StackTrace.xml", + "ref/dotnet/es/System.Diagnostics.StackTrace.xml", + "ref/dotnet/fr/System.Diagnostics.StackTrace.xml", + "ref/dotnet/it/System.Diagnostics.StackTrace.xml", + "ref/dotnet/ja/System.Diagnostics.StackTrace.xml", + "ref/dotnet/ko/System.Diagnostics.StackTrace.xml", + "ref/dotnet/ru/System.Diagnostics.StackTrace.xml", + "ref/dotnet/zh-hans/System.Diagnostics.StackTrace.xml", + "ref/dotnet/zh-hant/System.Diagnostics.StackTrace.xml", + "ref/net46/System.Diagnostics.StackTrace.dll", + "ref/xamarinios10/_._", + "ref/xamarinmac20/_._", + "runtimes/win8-aot/lib/netcore50/System.Diagnostics.StackTrace.dll" + ] + }, + "System.Diagnostics.Tools/4.0.0": { + "sha512": "uw5Qi2u5Cgtv4xv3+8DeB63iaprPcaEHfpeJqlJiLjIVy6v0La4ahJ6VW9oPbJNIjcavd24LKq0ctT9ssuQXsw==", + "type": "package", + "path": "System.Diagnostics.Tools/4.0.0", + "files": [ + "System.Diagnostics.Tools.4.0.0.nupkg.sha512", + "System.Diagnostics.Tools.nuspec", + "lib/DNXCore50/System.Diagnostics.Tools.dll", + "lib/net45/_._", + "lib/netcore50/System.Diagnostics.Tools.dll", + "lib/win8/_._", + "lib/wp80/_._", + "lib/wpa81/_._", + "ref/dotnet/System.Diagnostics.Tools.dll", + "ref/dotnet/System.Diagnostics.Tools.xml", + "ref/dotnet/de/System.Diagnostics.Tools.xml", + "ref/dotnet/es/System.Diagnostics.Tools.xml", + "ref/dotnet/fr/System.Diagnostics.Tools.xml", + "ref/dotnet/it/System.Diagnostics.Tools.xml", + "ref/dotnet/ja/System.Diagnostics.Tools.xml", + "ref/dotnet/ko/System.Diagnostics.Tools.xml", + "ref/dotnet/ru/System.Diagnostics.Tools.xml", + "ref/dotnet/zh-hans/System.Diagnostics.Tools.xml", + "ref/dotnet/zh-hant/System.Diagnostics.Tools.xml", + "ref/net45/_._", + "ref/netcore50/System.Diagnostics.Tools.dll", + "ref/netcore50/System.Diagnostics.Tools.xml", + "ref/win8/_._", + "ref/wp80/_._", + "ref/wpa81/_._", + "runtimes/win8-aot/lib/netcore50/System.Diagnostics.Tools.dll" + ] + }, + "System.Diagnostics.Tracing/4.0.20": { + "sha512": "gn/wexGHc35Fv++5L1gYHMY5g25COfiZ0PGrL+3PfwzoJd4X2LbTAm/U8d385SI6BKQBI/z4dQfvneS9J27+Tw==", + "type": "package", + "path": "System.Diagnostics.Tracing/4.0.20", + "files": [ + "System.Diagnostics.Tracing.4.0.20.nupkg.sha512", + "System.Diagnostics.Tracing.nuspec", + "lib/DNXCore50/System.Diagnostics.Tracing.dll", + "lib/MonoAndroid10/_._", + "lib/MonoTouch10/_._", + "lib/net46/_._", + "lib/netcore50/System.Diagnostics.Tracing.dll", + "lib/xamarinios10/_._", + "lib/xamarinmac20/_._", + "ref/MonoAndroid10/_._", + "ref/MonoTouch10/_._", + "ref/dotnet/System.Diagnostics.Tracing.dll", + "ref/dotnet/System.Diagnostics.Tracing.xml", + "ref/dotnet/de/System.Diagnostics.Tracing.xml", + "ref/dotnet/es/System.Diagnostics.Tracing.xml", + "ref/dotnet/fr/System.Diagnostics.Tracing.xml", + "ref/dotnet/it/System.Diagnostics.Tracing.xml", + "ref/dotnet/ja/System.Diagnostics.Tracing.xml", + "ref/dotnet/ko/System.Diagnostics.Tracing.xml", + "ref/dotnet/ru/System.Diagnostics.Tracing.xml", + "ref/dotnet/zh-hans/System.Diagnostics.Tracing.xml", + "ref/dotnet/zh-hant/System.Diagnostics.Tracing.xml", + "ref/net46/_._", + "ref/xamarinios10/_._", + "ref/xamarinmac20/_._", + "runtimes/win8-aot/lib/netcore50/System.Diagnostics.Tracing.dll" + ] + }, + "System.Dynamic.Runtime/4.0.10": { + "sha512": "r10VTLdlxtYp46BuxomHnwx7vIoMOr04CFoC/jJJfY22f7HQQ4P+cXY2Nxo6/rIxNNqOxwdbQQwv7Gl88Jsu1w==", + "type": "package", + "path": "System.Dynamic.Runtime/4.0.10", + "files": [ + "System.Dynamic.Runtime.4.0.10.nupkg.sha512", + "System.Dynamic.Runtime.nuspec", + "lib/DNXCore50/System.Dynamic.Runtime.dll", + "lib/MonoAndroid10/_._", + "lib/MonoTouch10/_._", + "lib/net46/_._", + "lib/netcore50/System.Dynamic.Runtime.dll", + "lib/xamarinios10/_._", + "lib/xamarinmac20/_._", + "ref/MonoAndroid10/_._", + "ref/MonoTouch10/_._", + "ref/dotnet/System.Dynamic.Runtime.dll", + "ref/dotnet/System.Dynamic.Runtime.xml", + "ref/dotnet/de/System.Dynamic.Runtime.xml", + "ref/dotnet/es/System.Dynamic.Runtime.xml", + "ref/dotnet/fr/System.Dynamic.Runtime.xml", + "ref/dotnet/it/System.Dynamic.Runtime.xml", + "ref/dotnet/ja/System.Dynamic.Runtime.xml", + "ref/dotnet/ko/System.Dynamic.Runtime.xml", + "ref/dotnet/ru/System.Dynamic.Runtime.xml", + "ref/dotnet/zh-hans/System.Dynamic.Runtime.xml", + "ref/dotnet/zh-hant/System.Dynamic.Runtime.xml", + "ref/net46/_._", + "ref/xamarinios10/_._", + "ref/xamarinmac20/_._", + "runtime.json", + "runtimes/win8-aot/lib/netcore50/System.Dynamic.Runtime.dll" + ] + }, + "System.Globalization/4.0.10": { + "sha512": "kzRtbbCNAxdafFBDogcM36ehA3th8c1PGiz8QRkZn8O5yMBorDHSK8/TGJPYOaCS5zdsGk0u9qXHnW91nqy7fw==", + "type": "package", + "path": "System.Globalization/4.0.10", + "files": [ + "System.Globalization.4.0.10.nupkg.sha512", + "System.Globalization.nuspec", + "lib/DNXCore50/System.Globalization.dll", + "lib/MonoAndroid10/_._", + "lib/MonoTouch10/_._", + "lib/net46/_._", + "lib/netcore50/System.Globalization.dll", + "lib/xamarinios10/_._", + "lib/xamarinmac20/_._", + "ref/MonoAndroid10/_._", + "ref/MonoTouch10/_._", + "ref/dotnet/System.Globalization.dll", + "ref/dotnet/System.Globalization.xml", + "ref/dotnet/de/System.Globalization.xml", + "ref/dotnet/es/System.Globalization.xml", + "ref/dotnet/fr/System.Globalization.xml", + "ref/dotnet/it/System.Globalization.xml", + "ref/dotnet/ja/System.Globalization.xml", + "ref/dotnet/ko/System.Globalization.xml", + "ref/dotnet/ru/System.Globalization.xml", + "ref/dotnet/zh-hans/System.Globalization.xml", + "ref/dotnet/zh-hant/System.Globalization.xml", + "ref/net46/_._", + "ref/xamarinios10/_._", + "ref/xamarinmac20/_._", + "runtimes/win8-aot/lib/netcore50/System.Globalization.dll" + ] + }, + "System.Globalization.Calendars/4.0.0": { + "sha512": "cL6WrdGKnNBx9W/iTr+jbffsEO4RLjEtOYcpVSzPNDoli6X5Q6bAfWtJYbJNOPi8Q0fXgBEvKK1ncFL/3FTqlA==", + "type": "package", + "path": "System.Globalization.Calendars/4.0.0", + "files": [ + "System.Globalization.Calendars.4.0.0.nupkg.sha512", + "System.Globalization.Calendars.nuspec", + "lib/DNXCore50/System.Globalization.Calendars.dll", + "lib/MonoAndroid10/_._", + "lib/MonoTouch10/_._", + "lib/net46/System.Globalization.Calendars.dll", + "lib/netcore50/System.Globalization.Calendars.dll", + "lib/xamarinios10/_._", + "lib/xamarinmac20/_._", + "ref/MonoAndroid10/_._", + "ref/MonoTouch10/_._", + "ref/dotnet/System.Globalization.Calendars.dll", + "ref/dotnet/System.Globalization.Calendars.xml", + "ref/dotnet/de/System.Globalization.Calendars.xml", + "ref/dotnet/es/System.Globalization.Calendars.xml", + "ref/dotnet/fr/System.Globalization.Calendars.xml", + "ref/dotnet/it/System.Globalization.Calendars.xml", + "ref/dotnet/ja/System.Globalization.Calendars.xml", + "ref/dotnet/ko/System.Globalization.Calendars.xml", + "ref/dotnet/ru/System.Globalization.Calendars.xml", + "ref/dotnet/zh-hans/System.Globalization.Calendars.xml", + "ref/dotnet/zh-hant/System.Globalization.Calendars.xml", + "ref/net46/System.Globalization.Calendars.dll", + "ref/xamarinios10/_._", + "ref/xamarinmac20/_._", + "runtimes/win8-aot/lib/netcore50/System.Globalization.Calendars.dll" + ] + }, + "System.Globalization.Extensions/4.0.0": { + "sha512": "rqbUXiwpBCvJ18ySCsjh20zleazO+6fr3s5GihC2sVwhyS0MUl6+oc5Rzk0z6CKkS4kmxbZQSeZLsK7cFSO0ng==", + "type": "package", + "path": "System.Globalization.Extensions/4.0.0", + "files": [ + "System.Globalization.Extensions.4.0.0.nupkg.sha512", + "System.Globalization.Extensions.nuspec", + "lib/MonoAndroid10/_._", + "lib/MonoTouch10/_._", + "lib/dotnet/System.Globalization.Extensions.dll", + "lib/net46/System.Globalization.Extensions.dll", + "lib/xamarinios10/_._", + "lib/xamarinmac20/_._", + "ref/MonoAndroid10/_._", + "ref/MonoTouch10/_._", + "ref/dotnet/System.Globalization.Extensions.dll", + "ref/dotnet/System.Globalization.Extensions.xml", + "ref/dotnet/de/System.Globalization.Extensions.xml", + "ref/dotnet/es/System.Globalization.Extensions.xml", + "ref/dotnet/fr/System.Globalization.Extensions.xml", + "ref/dotnet/it/System.Globalization.Extensions.xml", + "ref/dotnet/ja/System.Globalization.Extensions.xml", + "ref/dotnet/ko/System.Globalization.Extensions.xml", + "ref/dotnet/ru/System.Globalization.Extensions.xml", + "ref/dotnet/zh-hans/System.Globalization.Extensions.xml", + "ref/dotnet/zh-hant/System.Globalization.Extensions.xml", + "ref/net46/System.Globalization.Extensions.dll", + "ref/xamarinios10/_._", + "ref/xamarinmac20/_._" + ] + }, + "System.IO/4.0.10": { + "sha512": "kghf1CeYT+W2lw8a50/GxFz5HR9t6RkL4BvjxtTp1NxtEFWywnMA9W8FH/KYXiDNThcw9u/GOViDON4iJFGXIQ==", + "type": "package", + "path": "System.IO/4.0.10", + "files": [ + "System.IO.4.0.10.nupkg.sha512", + "System.IO.nuspec", + "lib/DNXCore50/System.IO.dll", + "lib/MonoAndroid10/_._", + "lib/MonoTouch10/_._", + "lib/net46/_._", + "lib/netcore50/System.IO.dll", + "lib/xamarinios10/_._", + "lib/xamarinmac20/_._", + "ref/MonoAndroid10/_._", + "ref/MonoTouch10/_._", + "ref/dotnet/System.IO.dll", + "ref/dotnet/System.IO.xml", + "ref/dotnet/de/System.IO.xml", + "ref/dotnet/es/System.IO.xml", + "ref/dotnet/fr/System.IO.xml", + "ref/dotnet/it/System.IO.xml", + "ref/dotnet/ja/System.IO.xml", + "ref/dotnet/ko/System.IO.xml", + "ref/dotnet/ru/System.IO.xml", + "ref/dotnet/zh-hans/System.IO.xml", + "ref/dotnet/zh-hant/System.IO.xml", + "ref/net46/_._", + "ref/xamarinios10/_._", + "ref/xamarinmac20/_._", + "runtimes/win8-aot/lib/netcore50/System.IO.dll" + ] + }, + "System.IO.Compression/4.0.0": { + "sha512": "S+ljBE3py8pujTrsOOYHtDg2cnAifn6kBu/pfh1hMWIXd8DoVh0ADTA6Puv4q+nYj+Msm6JoFLNwuRSmztbsDQ==", + "type": "package", + "path": "System.IO.Compression/4.0.0", + "files": [ + "System.IO.Compression.4.0.0.nupkg.sha512", + "System.IO.Compression.nuspec", + "lib/MonoAndroid10/_._", + "lib/MonoTouch10/_._", + "lib/dotnet/System.IO.Compression.dll", + "lib/net45/_._", + "lib/netcore50/System.IO.Compression.dll", + "lib/win8/_._", + "lib/wpa81/_._", + "lib/xamarinios10/_._", + "lib/xamarinmac20/_._", + "ref/MonoAndroid10/_._", + "ref/MonoTouch10/_._", + "ref/dotnet/System.IO.Compression.dll", + "ref/dotnet/System.IO.Compression.xml", + "ref/dotnet/de/System.IO.Compression.xml", + "ref/dotnet/es/System.IO.Compression.xml", + "ref/dotnet/fr/System.IO.Compression.xml", + "ref/dotnet/it/System.IO.Compression.xml", + "ref/dotnet/ja/System.IO.Compression.xml", + "ref/dotnet/ko/System.IO.Compression.xml", + "ref/dotnet/ru/System.IO.Compression.xml", + "ref/dotnet/zh-hans/System.IO.Compression.xml", + "ref/dotnet/zh-hant/System.IO.Compression.xml", + "ref/net45/_._", + "ref/netcore50/System.IO.Compression.dll", + "ref/netcore50/System.IO.Compression.xml", + "ref/win8/_._", + "ref/wpa81/_._", + "ref/xamarinios10/_._", + "ref/xamarinmac20/_._", + "runtime.json" + ] + }, + "System.IO.Compression.clrcompression-arm/4.0.0": { + "sha512": "Kk21GecAbI+H6tMP6/lMssGObbhoHwLiREiB5UkNMCypdxACuF+6gmrdDTousCUcbH28CJeo7tArrnUc+bchuw==", + "type": "package", + "path": "System.IO.Compression.clrcompression-arm/4.0.0", + "files": [ + "System.IO.Compression.clrcompression-arm.4.0.0.nupkg.sha512", + "System.IO.Compression.clrcompression-arm.nuspec", + "runtimes/win10-arm/native/ClrCompression.dll", + "runtimes/win7-arm/native/clrcompression.dll" + ] + }, + "System.IO.Compression.clrcompression-x64/4.0.0": { + "sha512": "Lqr+URMwKzf+8HJF6YrqEqzKzDzFJTE4OekaxqdIns71r8Ufbd8SbZa0LKl9q+7nu6Em4SkIEXVMB7plSXekOw==", + "type": "package", + "path": "System.IO.Compression.clrcompression-x64/4.0.0", + "files": [ + "System.IO.Compression.clrcompression-x64.4.0.0.nupkg.sha512", + "System.IO.Compression.clrcompression-x64.nuspec", + "runtimes/win10-x64/native/ClrCompression.dll", + "runtimes/win7-x64/native/clrcompression.dll" + ] + }, + "System.IO.Compression.clrcompression-x86/4.0.0": { + "sha512": "GmevpuaMRzYDXHu+xuV10fxTO8DsP7OKweWxYtkaxwVnDSj9X6RBupSiXdiveq9yj/xjZ1NbG+oRRRb99kj+VQ==", + "type": "package", + "path": "System.IO.Compression.clrcompression-x86/4.0.0", + "files": [ + "System.IO.Compression.clrcompression-x86.4.0.0.nupkg.sha512", + "System.IO.Compression.clrcompression-x86.nuspec", + "runtimes/win10-x86/native/ClrCompression.dll", + "runtimes/win7-x86/native/clrcompression.dll" + ] + }, + "System.IO.Compression.ZipFile/4.0.0": { + "sha512": "pwntmtsJqtt6Lez4Iyv4GVGW6DaXUTo9Rnlsx0MFagRgX+8F/sxG5S/IzDJabBj68sUWViz1QJrRZL4V9ngWDg==", + "type": "package", + "path": "System.IO.Compression.ZipFile/4.0.0", + "files": [ + "System.IO.Compression.ZipFile.4.0.0.nupkg.sha512", + "System.IO.Compression.ZipFile.nuspec", + "lib/MonoAndroid10/_._", + "lib/MonoTouch10/_._", + "lib/dotnet/System.IO.Compression.ZipFile.dll", + "lib/net46/System.IO.Compression.ZipFile.dll", + "lib/xamarinios10/_._", + "lib/xamarinmac20/_._", + "ref/MonoAndroid10/_._", + "ref/MonoTouch10/_._", + "ref/dotnet/System.IO.Compression.ZipFile.dll", + "ref/dotnet/System.IO.Compression.ZipFile.xml", + "ref/dotnet/de/System.IO.Compression.ZipFile.xml", + "ref/dotnet/es/System.IO.Compression.ZipFile.xml", + "ref/dotnet/fr/System.IO.Compression.ZipFile.xml", + "ref/dotnet/it/System.IO.Compression.ZipFile.xml", + "ref/dotnet/ja/System.IO.Compression.ZipFile.xml", + "ref/dotnet/ko/System.IO.Compression.ZipFile.xml", + "ref/dotnet/ru/System.IO.Compression.ZipFile.xml", + "ref/dotnet/zh-hans/System.IO.Compression.ZipFile.xml", + "ref/dotnet/zh-hant/System.IO.Compression.ZipFile.xml", + "ref/net46/System.IO.Compression.ZipFile.dll", + "ref/xamarinios10/_._", + "ref/xamarinmac20/_._" + ] + }, + "System.IO.FileSystem/4.0.0": { + "sha512": "eo05SPWfG+54UA0wxgRIYOuOslq+2QrJLXZaJDDsfLXG15OLguaItW39NYZTqUb4DeGOkU4R0wpOLOW4ynMUDQ==", + "type": "package", + "path": "System.IO.FileSystem/4.0.0", + "files": [ + "System.IO.FileSystem.4.0.0.nupkg.sha512", + "System.IO.FileSystem.nuspec", + "lib/DNXCore50/System.IO.FileSystem.dll", + "lib/MonoAndroid10/_._", + "lib/MonoTouch10/_._", + "lib/net46/System.IO.FileSystem.dll", + "lib/netcore50/System.IO.FileSystem.dll", + "lib/xamarinios10/_._", + "lib/xamarinmac20/_._", + "ref/MonoAndroid10/_._", + "ref/MonoTouch10/_._", + "ref/dotnet/System.IO.FileSystem.dll", + "ref/dotnet/System.IO.FileSystem.xml", + "ref/dotnet/de/System.IO.FileSystem.xml", + "ref/dotnet/es/System.IO.FileSystem.xml", + "ref/dotnet/fr/System.IO.FileSystem.xml", + "ref/dotnet/it/System.IO.FileSystem.xml", + "ref/dotnet/ja/System.IO.FileSystem.xml", + "ref/dotnet/ko/System.IO.FileSystem.xml", + "ref/dotnet/ru/System.IO.FileSystem.xml", + "ref/dotnet/zh-hans/System.IO.FileSystem.xml", + "ref/dotnet/zh-hant/System.IO.FileSystem.xml", + "ref/net46/System.IO.FileSystem.dll", + "ref/xamarinios10/_._", + "ref/xamarinmac20/_._" + ] + }, + "System.IO.FileSystem.Primitives/4.0.0": { + "sha512": "7pJUvYi/Yq3A5nagqCCiOw3+aJp3xXc/Cjr8dnJDnER3/6kX3LEencfqmXUcPl9+7OvRNyPMNhqsLAcMK6K/KA==", + "type": "package", + "path": "System.IO.FileSystem.Primitives/4.0.0", + "files": [ + "System.IO.FileSystem.Primitives.4.0.0.nupkg.sha512", + "System.IO.FileSystem.Primitives.nuspec", + "lib/MonoAndroid10/_._", + "lib/MonoTouch10/_._", + "lib/dotnet/System.IO.FileSystem.Primitives.dll", + "lib/net46/System.IO.FileSystem.Primitives.dll", + "lib/xamarinios10/_._", + "lib/xamarinmac20/_._", + "ref/MonoAndroid10/_._", + "ref/MonoTouch10/_._", + "ref/dotnet/System.IO.FileSystem.Primitives.dll", + "ref/dotnet/System.IO.FileSystem.Primitives.xml", + "ref/dotnet/de/System.IO.FileSystem.Primitives.xml", + "ref/dotnet/es/System.IO.FileSystem.Primitives.xml", + "ref/dotnet/fr/System.IO.FileSystem.Primitives.xml", + "ref/dotnet/it/System.IO.FileSystem.Primitives.xml", + "ref/dotnet/ja/System.IO.FileSystem.Primitives.xml", + "ref/dotnet/ko/System.IO.FileSystem.Primitives.xml", + "ref/dotnet/ru/System.IO.FileSystem.Primitives.xml", + "ref/dotnet/zh-hans/System.IO.FileSystem.Primitives.xml", + "ref/dotnet/zh-hant/System.IO.FileSystem.Primitives.xml", + "ref/net46/System.IO.FileSystem.Primitives.dll", + "ref/xamarinios10/_._", + "ref/xamarinmac20/_._" + ] + }, + "System.IO.UnmanagedMemoryStream/4.0.0": { + "sha512": "i2xczgQfwHmolORBNHxV9b5izP8VOBxgSA2gf+H55xBvwqtR+9r9adtzlc7at0MAwiLcsk6V1TZlv2vfRQr8Sw==", + "type": "package", + "path": "System.IO.UnmanagedMemoryStream/4.0.0", + "files": [ + "System.IO.UnmanagedMemoryStream.4.0.0.nupkg.sha512", + "System.IO.UnmanagedMemoryStream.nuspec", + "lib/MonoAndroid10/_._", + "lib/MonoTouch10/_._", + "lib/dotnet/System.IO.UnmanagedMemoryStream.dll", + "lib/net46/System.IO.UnmanagedMemoryStream.dll", + "lib/xamarinios10/_._", + "lib/xamarinmac20/_._", + "ref/MonoAndroid10/_._", + "ref/MonoTouch10/_._", + "ref/dotnet/System.IO.UnmanagedMemoryStream.dll", + "ref/dotnet/System.IO.UnmanagedMemoryStream.xml", + "ref/dotnet/de/System.IO.UnmanagedMemoryStream.xml", + "ref/dotnet/es/System.IO.UnmanagedMemoryStream.xml", + "ref/dotnet/fr/System.IO.UnmanagedMemoryStream.xml", + "ref/dotnet/it/System.IO.UnmanagedMemoryStream.xml", + "ref/dotnet/ja/System.IO.UnmanagedMemoryStream.xml", + "ref/dotnet/ko/System.IO.UnmanagedMemoryStream.xml", + "ref/dotnet/ru/System.IO.UnmanagedMemoryStream.xml", + "ref/dotnet/zh-hans/System.IO.UnmanagedMemoryStream.xml", + "ref/dotnet/zh-hant/System.IO.UnmanagedMemoryStream.xml", + "ref/net46/System.IO.UnmanagedMemoryStream.dll", + "ref/xamarinios10/_._", + "ref/xamarinmac20/_._" + ] + }, + "System.Linq/4.0.0": { + "sha512": "r6Hlc+ytE6m/9UBr+nNRRdoJEWjoeQiT3L3lXYFDHoXk3VYsRBCDNXrawcexw7KPLaH0zamQLiAb6avhZ50cGg==", + "type": "package", + "path": "System.Linq/4.0.0", + "files": [ + "System.Linq.4.0.0.nupkg.sha512", + "System.Linq.nuspec", + "lib/dotnet/System.Linq.dll", + "lib/net45/_._", + "lib/netcore50/System.Linq.dll", + "lib/win8/_._", + "lib/wp80/_._", + "lib/wpa81/_._", + "ref/dotnet/System.Linq.dll", + "ref/dotnet/System.Linq.xml", + "ref/dotnet/de/System.Linq.xml", + "ref/dotnet/es/System.Linq.xml", + "ref/dotnet/fr/System.Linq.xml", + "ref/dotnet/it/System.Linq.xml", + "ref/dotnet/ja/System.Linq.xml", + "ref/dotnet/ko/System.Linq.xml", + "ref/dotnet/ru/System.Linq.xml", + "ref/dotnet/zh-hans/System.Linq.xml", + "ref/dotnet/zh-hant/System.Linq.xml", + "ref/net45/_._", + "ref/netcore50/System.Linq.dll", + "ref/netcore50/System.Linq.xml", + "ref/win8/_._", + "ref/wp80/_._", + "ref/wpa81/_._" + ] + }, + "System.Linq.Expressions/4.0.10": { + "sha512": "qhFkPqRsTfXBaacjQhxwwwUoU7TEtwlBIULj7nG7i4qAkvivil31VvOvDKppCSui5yGw0/325ZeNaMYRvTotXw==", + "type": "package", + "path": "System.Linq.Expressions/4.0.10", + "files": [ + "System.Linq.Expressions.4.0.10.nupkg.sha512", + "System.Linq.Expressions.nuspec", + "lib/DNXCore50/System.Linq.Expressions.dll", + "lib/MonoAndroid10/_._", + "lib/MonoTouch10/_._", + "lib/net46/_._", + "lib/netcore50/System.Linq.Expressions.dll", + "lib/xamarinios10/_._", + "lib/xamarinmac20/_._", + "ref/MonoAndroid10/_._", + "ref/MonoTouch10/_._", + "ref/dotnet/System.Linq.Expressions.dll", + "ref/dotnet/System.Linq.Expressions.xml", + "ref/dotnet/de/System.Linq.Expressions.xml", + "ref/dotnet/es/System.Linq.Expressions.xml", + "ref/dotnet/fr/System.Linq.Expressions.xml", + "ref/dotnet/it/System.Linq.Expressions.xml", + "ref/dotnet/ja/System.Linq.Expressions.xml", + "ref/dotnet/ko/System.Linq.Expressions.xml", + "ref/dotnet/ru/System.Linq.Expressions.xml", + "ref/dotnet/zh-hans/System.Linq.Expressions.xml", + "ref/dotnet/zh-hant/System.Linq.Expressions.xml", + "ref/net46/_._", + "ref/xamarinios10/_._", + "ref/xamarinmac20/_._", + "runtime.json", + "runtimes/win8-aot/lib/netcore50/System.Linq.Expressions.dll" + ] + }, + "System.Linq.Parallel/4.0.0": { + "sha512": "PtH7KKh1BbzVow4XY17pnrn7Io63ApMdwzRE2o2HnzsKQD/0o7X5xe6mxrDUqTm9ZCR3/PNhAlP13VY1HnHsbA==", + "type": "package", + "path": "System.Linq.Parallel/4.0.0", + "files": [ + "System.Linq.Parallel.4.0.0.nupkg.sha512", + "System.Linq.Parallel.nuspec", + "lib/dotnet/System.Linq.Parallel.dll", + "lib/net45/_._", + "lib/netcore50/System.Linq.Parallel.dll", + "lib/win8/_._", + "lib/wpa81/_._", + "ref/dotnet/System.Linq.Parallel.dll", + "ref/dotnet/System.Linq.Parallel.xml", + "ref/dotnet/de/System.Linq.Parallel.xml", + "ref/dotnet/es/System.Linq.Parallel.xml", + "ref/dotnet/fr/System.Linq.Parallel.xml", + "ref/dotnet/it/System.Linq.Parallel.xml", + "ref/dotnet/ja/System.Linq.Parallel.xml", + "ref/dotnet/ko/System.Linq.Parallel.xml", + "ref/dotnet/ru/System.Linq.Parallel.xml", + "ref/dotnet/zh-hans/System.Linq.Parallel.xml", + "ref/dotnet/zh-hant/System.Linq.Parallel.xml", + "ref/net45/_._", + "ref/netcore50/System.Linq.Parallel.dll", + "ref/netcore50/System.Linq.Parallel.xml", + "ref/win8/_._", + "ref/wpa81/_._" + ] + }, + "System.Linq.Queryable/4.0.0": { + "sha512": "DIlvCNn3ucFvwMMzXcag4aFnFJ1fdxkQ5NqwJe9Nh7y8ozzhDm07YakQL/yoF3P1dLzY1T2cTpuwbAmVSdXyBA==", + "type": "package", + "path": "System.Linq.Queryable/4.0.0", + "files": [ + "System.Linq.Queryable.4.0.0.nupkg.sha512", + "System.Linq.Queryable.nuspec", + "lib/dotnet/System.Linq.Queryable.dll", + "lib/net45/_._", + "lib/netcore50/System.Linq.Queryable.dll", + "lib/win8/_._", + "lib/wp80/_._", + "lib/wpa81/_._", + "ref/dotnet/System.Linq.Queryable.dll", + "ref/dotnet/System.Linq.Queryable.xml", + "ref/dotnet/de/System.Linq.Queryable.xml", + "ref/dotnet/es/System.Linq.Queryable.xml", + "ref/dotnet/fr/System.Linq.Queryable.xml", + "ref/dotnet/it/System.Linq.Queryable.xml", + "ref/dotnet/ja/System.Linq.Queryable.xml", + "ref/dotnet/ko/System.Linq.Queryable.xml", + "ref/dotnet/ru/System.Linq.Queryable.xml", + "ref/dotnet/zh-hans/System.Linq.Queryable.xml", + "ref/dotnet/zh-hant/System.Linq.Queryable.xml", + "ref/net45/_._", + "ref/netcore50/System.Linq.Queryable.dll", + "ref/netcore50/System.Linq.Queryable.xml", + "ref/win8/_._", + "ref/wp80/_._", + "ref/wpa81/_._" + ] + }, + "System.Net.Http/4.0.0": { + "sha512": "mZuAl7jw/mFY8jUq4ITKECxVBh9a8SJt9BC/+lJbmo7cRKspxE3PsITz+KiaCEsexN5WYPzwBOx0oJH/0HlPyQ==", + "type": "package", + "path": "System.Net.Http/4.0.0", + "files": [ + "System.Net.Http.4.0.0.nupkg.sha512", + "System.Net.Http.nuspec", + "lib/DNXCore50/System.Net.Http.dll", + "lib/net45/_._", + "lib/netcore50/System.Net.Http.dll", + "lib/win8/_._", + "lib/wpa81/_._", + "ref/dotnet/System.Net.Http.dll", + "ref/dotnet/System.Net.Http.xml", + "ref/dotnet/de/System.Net.Http.xml", + "ref/dotnet/es/System.Net.Http.xml", + "ref/dotnet/fr/System.Net.Http.xml", + "ref/dotnet/it/System.Net.Http.xml", + "ref/dotnet/ja/System.Net.Http.xml", + "ref/dotnet/ko/System.Net.Http.xml", + "ref/dotnet/ru/System.Net.Http.xml", + "ref/dotnet/zh-hans/System.Net.Http.xml", + "ref/dotnet/zh-hant/System.Net.Http.xml", + "ref/net45/_._", + "ref/netcore50/System.Net.Http.dll", + "ref/netcore50/System.Net.Http.xml", + "ref/win8/_._", + "ref/wpa81/_._" + ] + }, + "System.Net.NetworkInformation/4.0.0": { + "sha512": "D68KCf5VK1G1GgFUwD901gU6cnMITksOdfdxUCt9ReCZfT1pigaDqjJ7XbiLAM4jm7TfZHB7g5mbOf1mbG3yBA==", + "type": "package", + "path": "System.Net.NetworkInformation/4.0.0", + "files": [ + "System.Net.NetworkInformation.4.0.0.nupkg.sha512", + "System.Net.NetworkInformation.nuspec", + "lib/MonoAndroid10/_._", + "lib/MonoTouch10/_._", + "lib/net45/_._", + "lib/netcore50/System.Net.NetworkInformation.dll", + "lib/win8/_._", + "lib/wp80/_._", + "lib/wpa81/_._", + "lib/xamarinios10/_._", + "lib/xamarinmac20/_._", + "ref/MonoAndroid10/_._", + "ref/MonoTouch10/_._", + "ref/dotnet/System.Net.NetworkInformation.dll", + "ref/dotnet/System.Net.NetworkInformation.xml", + "ref/dotnet/de/System.Net.NetworkInformation.xml", + "ref/dotnet/es/System.Net.NetworkInformation.xml", + "ref/dotnet/fr/System.Net.NetworkInformation.xml", + "ref/dotnet/it/System.Net.NetworkInformation.xml", + "ref/dotnet/ja/System.Net.NetworkInformation.xml", + "ref/dotnet/ko/System.Net.NetworkInformation.xml", + "ref/dotnet/ru/System.Net.NetworkInformation.xml", + "ref/dotnet/zh-hans/System.Net.NetworkInformation.xml", + "ref/dotnet/zh-hant/System.Net.NetworkInformation.xml", + "ref/net45/_._", + "ref/netcore50/System.Net.NetworkInformation.dll", + "ref/netcore50/System.Net.NetworkInformation.xml", + "ref/win8/_._", + "ref/wp80/_._", + "ref/wpa81/_._", + "ref/xamarinios10/_._", + "ref/xamarinmac20/_._" + ] + }, + "System.Net.NetworkInformation/4.0.10-beta-23123": { + "sha512": "NkKpsUm2MLoxT+YlSwexidAw2jGFIJuc6i4H9pT3nU3TQj7MZVursD/ohWj3nyBxthy7i00XLWkRZAwGao/zsg==", + "type": "package", + "path": "System.Net.NetworkInformation/4.0.10-beta-23123", + "files": [ + "System.Net.NetworkInformation.4.0.10-beta-23123.nupkg.sha512", + "System.Net.NetworkInformation.nuspec", + "lib/DNXCore50/System.Net.NetworkInformation.dll", + "lib/MonoAndroid10/_._", + "lib/MonoTouch10/_._", + "lib/net46/_._", + "lib/xamarinios10/_._", + "lib/xamarinmac20/_._", + "ref/MonoAndroid10/_._", + "ref/MonoTouch10/_._", + "ref/dotnet/System.Net.NetworkInformation.dll", + "ref/dotnet/System.Net.NetworkInformation.xml", + "ref/dotnet/de/System.Net.NetworkInformation.xml", + "ref/dotnet/es/System.Net.NetworkInformation.xml", + "ref/dotnet/fr/System.Net.NetworkInformation.xml", + "ref/dotnet/it/System.Net.NetworkInformation.xml", + "ref/dotnet/ja/System.Net.NetworkInformation.xml", + "ref/dotnet/ko/System.Net.NetworkInformation.xml", + "ref/dotnet/ru/System.Net.NetworkInformation.xml", + "ref/dotnet/zh-hans/System.Net.NetworkInformation.xml", + "ref/dotnet/zh-hant/System.Net.NetworkInformation.xml", + "ref/net46/_._", + "ref/xamarinios10/_._", + "ref/xamarinmac20/_._" + ] + }, + "System.Net.Primitives/4.0.10": { + "sha512": "YQqIpmMhnKjIbT7rl6dlf7xM5DxaMR+whduZ9wKb9OhMLjoueAJO3HPPJI+Naf3v034kb+xZqdc3zo44o3HWcg==", + "type": "package", + "path": "System.Net.Primitives/4.0.10", + "files": [ + "System.Net.Primitives.4.0.10.nupkg.sha512", + "System.Net.Primitives.nuspec", + "lib/DNXCore50/System.Net.Primitives.dll", + "lib/MonoAndroid10/_._", + "lib/MonoTouch10/_._", + "lib/net46/_._", + "lib/netcore50/System.Net.Primitives.dll", + "lib/xamarinios10/_._", + "lib/xamarinmac20/_._", + "ref/MonoAndroid10/_._", + "ref/MonoTouch10/_._", + "ref/dotnet/System.Net.Primitives.dll", + "ref/dotnet/System.Net.Primitives.xml", + "ref/dotnet/de/System.Net.Primitives.xml", + "ref/dotnet/es/System.Net.Primitives.xml", + "ref/dotnet/fr/System.Net.Primitives.xml", + "ref/dotnet/it/System.Net.Primitives.xml", + "ref/dotnet/ja/System.Net.Primitives.xml", + "ref/dotnet/ko/System.Net.Primitives.xml", + "ref/dotnet/ru/System.Net.Primitives.xml", + "ref/dotnet/zh-hans/System.Net.Primitives.xml", + "ref/dotnet/zh-hant/System.Net.Primitives.xml", + "ref/net46/_._", + "ref/xamarinios10/_._", + "ref/xamarinmac20/_._" + ] + }, + "System.Numerics.Vectors/4.1.0": { + "sha512": "jpubR06GWPoZA0oU5xLM7kHeV59/CKPBXZk4Jfhi0T3DafxbrdueHZ8kXlb+Fb5nd3DAyyMh2/eqEzLX0xv6Qg==", + "type": "package", + "path": "System.Numerics.Vectors/4.1.0", + "files": [ + "System.Numerics.Vectors.4.1.0.nupkg.sha512", + "System.Numerics.Vectors.nuspec", + "lib/MonoAndroid10/_._", + "lib/MonoTouch10/_._", + "lib/dotnet/System.Numerics.Vectors.dll", + "lib/net46/System.Numerics.Vectors.dll", + "lib/xamarinios10/_._", + "lib/xamarinmac20/_._", + "ref/MonoAndroid10/_._", + "ref/MonoTouch10/_._", + "ref/dotnet/System.Numerics.Vectors.dll", + "ref/net46/System.Numerics.Vectors.dll", + "ref/xamarinios10/_._", + "ref/xamarinmac20/_._" + ] + }, + "System.ObjectModel/4.0.10": { + "sha512": "Djn1wb0vP662zxbe+c3mOhvC4vkQGicsFs1Wi0/GJJpp3Eqp+oxbJ+p2Sx3O0efYueggAI5SW+BqEoczjfr1cA==", + "type": "package", + "path": "System.ObjectModel/4.0.10", + "files": [ + "System.ObjectModel.4.0.10.nupkg.sha512", + "System.ObjectModel.nuspec", + "lib/MonoAndroid10/_._", + "lib/MonoTouch10/_._", + "lib/dotnet/System.ObjectModel.dll", + "lib/net46/_._", + "lib/xamarinios10/_._", + "lib/xamarinmac20/_._", + "ref/MonoAndroid10/_._", + "ref/MonoTouch10/_._", + "ref/dotnet/System.ObjectModel.dll", + "ref/dotnet/System.ObjectModel.xml", + "ref/dotnet/de/System.ObjectModel.xml", + "ref/dotnet/es/System.ObjectModel.xml", + "ref/dotnet/fr/System.ObjectModel.xml", + "ref/dotnet/it/System.ObjectModel.xml", + "ref/dotnet/ja/System.ObjectModel.xml", + "ref/dotnet/ko/System.ObjectModel.xml", + "ref/dotnet/ru/System.ObjectModel.xml", + "ref/dotnet/zh-hans/System.ObjectModel.xml", + "ref/dotnet/zh-hant/System.ObjectModel.xml", + "ref/net46/_._", + "ref/xamarinios10/_._", + "ref/xamarinmac20/_._" + ] + }, + "System.Private.Networking/4.0.0": { + "sha512": "RUEqdBdJjISC65dO8l4LdN7vTdlXH+attUpKnauDUHVtLbIKdlDB9LKoLzCQsTQRP7vzUJHWYXznHJBkjAA7yA==", + "type": "package", + "path": "System.Private.Networking/4.0.0", + "files": [ + "System.Private.Networking.4.0.0.nupkg.sha512", + "System.Private.Networking.nuspec", + "lib/DNXCore50/System.Private.Networking.dll", + "lib/netcore50/System.Private.Networking.dll", + "ref/dnxcore50/_._", + "ref/netcore50/_._" + ] + }, + "System.Private.Uri/4.0.0": { + "sha512": "CtuxaCKcRIvPcsqquVl3mPp79EDZPMr2UogfiFCxCs+t2z1VjbpQsKNs1GHZ8VQetqbk1mr0V1yAfMe6y8CHDA==", + "type": "package", + "path": "System.Private.Uri/4.0.0", + "files": [ + "System.Private.Uri.4.0.0.nupkg.sha512", + "System.Private.Uri.nuspec", + "lib/DNXCore50/System.Private.Uri.dll", + "lib/netcore50/System.Private.Uri.dll", + "ref/dnxcore50/_._", + "ref/netcore50/_._", + "runtimes/win8-aot/lib/netcore50/System.Private.Uri.dll" + ] + }, + "System.Reflection/4.0.10": { + "sha512": "WZ+4lEE4gqGx6mrqLhSiW4oi6QLPWwdNjzhhTONmhELOrW8Cw9phlO9tltgvRUuQUqYtBiliFwhO5S5fCJElVw==", + "type": "package", + "path": "System.Reflection/4.0.10", + "files": [ + "System.Reflection.4.0.10.nupkg.sha512", + "System.Reflection.nuspec", + "lib/DNXCore50/System.Reflection.dll", + "lib/MonoAndroid10/_._", + "lib/MonoTouch10/_._", + "lib/net46/_._", + "lib/netcore50/System.Reflection.dll", + "lib/xamarinios10/_._", + "lib/xamarinmac20/_._", + "ref/MonoAndroid10/_._", + "ref/MonoTouch10/_._", + "ref/dotnet/System.Reflection.dll", + "ref/dotnet/System.Reflection.xml", + "ref/dotnet/de/System.Reflection.xml", + "ref/dotnet/es/System.Reflection.xml", + "ref/dotnet/fr/System.Reflection.xml", + "ref/dotnet/it/System.Reflection.xml", + "ref/dotnet/ja/System.Reflection.xml", + "ref/dotnet/ko/System.Reflection.xml", + "ref/dotnet/ru/System.Reflection.xml", + "ref/dotnet/zh-hans/System.Reflection.xml", + "ref/dotnet/zh-hant/System.Reflection.xml", + "ref/net46/_._", + "ref/xamarinios10/_._", + "ref/xamarinmac20/_._", + "runtimes/win8-aot/lib/netcore50/System.Reflection.dll" + ] + }, + "System.Reflection.DispatchProxy/4.0.0": { + "sha512": "Kd/4o6DqBfJA4058X8oGEu1KlT8Ej0A+WGeoQgZU2h+3f2vC8NRbHxeOSZvxj9/MPZ1RYmZMGL1ApO9xG/4IVA==", + "type": "package", + "path": "System.Reflection.DispatchProxy/4.0.0", + "files": [ + "System.Reflection.DispatchProxy.4.0.0.nupkg.sha512", + "System.Reflection.DispatchProxy.nuspec", + "lib/DNXCore50/System.Reflection.DispatchProxy.dll", + "lib/MonoAndroid10/_._", + "lib/MonoTouch10/_._", + "lib/net46/System.Reflection.DispatchProxy.dll", + "lib/netcore50/System.Reflection.DispatchProxy.dll", + "lib/xamarinios10/_._", + "lib/xamarinmac20/_._", + "ref/MonoAndroid10/_._", + "ref/MonoTouch10/_._", + "ref/dotnet/System.Reflection.DispatchProxy.dll", + "ref/dotnet/System.Reflection.DispatchProxy.xml", + "ref/dotnet/de/System.Reflection.DispatchProxy.xml", + "ref/dotnet/es/System.Reflection.DispatchProxy.xml", + "ref/dotnet/fr/System.Reflection.DispatchProxy.xml", + "ref/dotnet/it/System.Reflection.DispatchProxy.xml", + "ref/dotnet/ja/System.Reflection.DispatchProxy.xml", + "ref/dotnet/ko/System.Reflection.DispatchProxy.xml", + "ref/dotnet/ru/System.Reflection.DispatchProxy.xml", + "ref/dotnet/zh-hans/System.Reflection.DispatchProxy.xml", + "ref/dotnet/zh-hant/System.Reflection.DispatchProxy.xml", + "ref/xamarinios10/_._", + "ref/xamarinmac20/_._", + "runtime.json", + "runtimes/win8-aot/lib/netcore50/System.Reflection.DispatchProxy.dll" + ] + }, + "System.Reflection.Emit/4.0.0": { + "sha512": "CqnQz5LbNbiSxN10cv3Ehnw3j1UZOBCxnE0OO0q/keGQ5ENjyFM6rIG4gm/i0dX6EjdpYkAgKcI/mhZZCaBq4A==", + "type": "package", + "path": "System.Reflection.Emit/4.0.0", + "files": [ + "System.Reflection.Emit.4.0.0.nupkg.sha512", + "System.Reflection.Emit.nuspec", + "lib/DNXCore50/System.Reflection.Emit.dll", + "lib/MonoAndroid10/_._", + "lib/net45/_._", + "lib/netcore50/System.Reflection.Emit.dll", + "lib/xamarinmac20/_._", + "ref/MonoAndroid10/_._", + "ref/dotnet/System.Reflection.Emit.dll", + "ref/dotnet/System.Reflection.Emit.xml", + "ref/dotnet/de/System.Reflection.Emit.xml", + "ref/dotnet/es/System.Reflection.Emit.xml", + "ref/dotnet/fr/System.Reflection.Emit.xml", + "ref/dotnet/it/System.Reflection.Emit.xml", + "ref/dotnet/ja/System.Reflection.Emit.xml", + "ref/dotnet/ko/System.Reflection.Emit.xml", + "ref/dotnet/ru/System.Reflection.Emit.xml", + "ref/dotnet/zh-hans/System.Reflection.Emit.xml", + "ref/dotnet/zh-hant/System.Reflection.Emit.xml", + "ref/net45/_._", + "ref/xamarinmac20/_._" + ] + }, + "System.Reflection.Emit.ILGeneration/4.0.0": { + "sha512": "02okuusJ0GZiHZSD2IOLIN41GIn6qOr7i5+86C98BPuhlwWqVABwebiGNvhDiXP1f9a6CxEigC7foQD42klcDg==", + "type": "package", + "path": "System.Reflection.Emit.ILGeneration/4.0.0", + "files": [ + "System.Reflection.Emit.ILGeneration.4.0.0.nupkg.sha512", + "System.Reflection.Emit.ILGeneration.nuspec", + "lib/DNXCore50/System.Reflection.Emit.ILGeneration.dll", + "lib/net45/_._", + "lib/netcore50/System.Reflection.Emit.ILGeneration.dll", + "lib/wp80/_._", + "ref/dotnet/System.Reflection.Emit.ILGeneration.dll", + "ref/dotnet/System.Reflection.Emit.ILGeneration.xml", + "ref/dotnet/de/System.Reflection.Emit.ILGeneration.xml", + "ref/dotnet/es/System.Reflection.Emit.ILGeneration.xml", + "ref/dotnet/fr/System.Reflection.Emit.ILGeneration.xml", + "ref/dotnet/it/System.Reflection.Emit.ILGeneration.xml", + "ref/dotnet/ja/System.Reflection.Emit.ILGeneration.xml", + "ref/dotnet/ko/System.Reflection.Emit.ILGeneration.xml", + "ref/dotnet/ru/System.Reflection.Emit.ILGeneration.xml", + "ref/dotnet/zh-hans/System.Reflection.Emit.ILGeneration.xml", + "ref/dotnet/zh-hant/System.Reflection.Emit.ILGeneration.xml", + "ref/net45/_._", + "ref/wp80/_._" + ] + }, + "System.Reflection.Emit.Lightweight/4.0.0": { + "sha512": "DJZhHiOdkN08xJgsJfDjkuOreLLmMcU8qkEEqEHqyhkPUZMMQs0lE8R+6+68BAFWgcdzxtNu0YmIOtEug8j00w==", + "type": "package", + "path": "System.Reflection.Emit.Lightweight/4.0.0", + "files": [ + "System.Reflection.Emit.Lightweight.4.0.0.nupkg.sha512", + "System.Reflection.Emit.Lightweight.nuspec", + "lib/DNXCore50/System.Reflection.Emit.Lightweight.dll", + "lib/net45/_._", + "lib/netcore50/System.Reflection.Emit.Lightweight.dll", + "lib/wp80/_._", + "ref/dotnet/System.Reflection.Emit.Lightweight.dll", + "ref/dotnet/System.Reflection.Emit.Lightweight.xml", + "ref/dotnet/de/System.Reflection.Emit.Lightweight.xml", + "ref/dotnet/es/System.Reflection.Emit.Lightweight.xml", + "ref/dotnet/fr/System.Reflection.Emit.Lightweight.xml", + "ref/dotnet/it/System.Reflection.Emit.Lightweight.xml", + "ref/dotnet/ja/System.Reflection.Emit.Lightweight.xml", + "ref/dotnet/ko/System.Reflection.Emit.Lightweight.xml", + "ref/dotnet/ru/System.Reflection.Emit.Lightweight.xml", + "ref/dotnet/zh-hans/System.Reflection.Emit.Lightweight.xml", + "ref/dotnet/zh-hant/System.Reflection.Emit.Lightweight.xml", + "ref/net45/_._", + "ref/wp80/_._" + ] + }, + "System.Reflection.Extensions/4.0.0": { + "sha512": "dbYaZWCyFAu1TGYUqR2n+Q+1casSHPR2vVW0WVNkXpZbrd2BXcZ7cpvpu9C98CTHtNmyfMWCLpCclDqly23t6A==", + "type": "package", + "path": "System.Reflection.Extensions/4.0.0", + "files": [ + "System.Reflection.Extensions.4.0.0.nupkg.sha512", + "System.Reflection.Extensions.nuspec", + "lib/DNXCore50/System.Reflection.Extensions.dll", + "lib/net45/_._", + "lib/netcore50/System.Reflection.Extensions.dll", + "lib/win8/_._", + "lib/wp80/_._", + "lib/wpa81/_._", + "ref/dotnet/System.Reflection.Extensions.dll", + "ref/dotnet/System.Reflection.Extensions.xml", + "ref/dotnet/de/System.Reflection.Extensions.xml", + "ref/dotnet/es/System.Reflection.Extensions.xml", + "ref/dotnet/fr/System.Reflection.Extensions.xml", + "ref/dotnet/it/System.Reflection.Extensions.xml", + "ref/dotnet/ja/System.Reflection.Extensions.xml", + "ref/dotnet/ko/System.Reflection.Extensions.xml", + "ref/dotnet/ru/System.Reflection.Extensions.xml", + "ref/dotnet/zh-hans/System.Reflection.Extensions.xml", + "ref/dotnet/zh-hant/System.Reflection.Extensions.xml", + "ref/net45/_._", + "ref/netcore50/System.Reflection.Extensions.dll", + "ref/netcore50/System.Reflection.Extensions.xml", + "ref/win8/_._", + "ref/wp80/_._", + "ref/wpa81/_._", + "runtimes/win8-aot/lib/netcore50/System.Reflection.Extensions.dll" + ] + }, + "System.Reflection.Metadata/1.0.22": { + "sha512": "ltoL/teiEdy5W9fyYdtFr2xJ/4nHyksXLK9dkPWx3ubnj7BVfsSWxvWTg9EaJUXjhWvS/AeTtugZA1/IDQyaPQ==", + "type": "package", + "path": "System.Reflection.Metadata/1.0.22", + "files": [ + "System.Reflection.Metadata.1.0.22.nupkg.sha512", + "System.Reflection.Metadata.nuspec", + "lib/dotnet/System.Reflection.Metadata.dll", + "lib/dotnet/System.Reflection.Metadata.xml", + "lib/portable-net45+win8/System.Reflection.Metadata.dll", + "lib/portable-net45+win8/System.Reflection.Metadata.xml" + ] + }, + "System.Reflection.Primitives/4.0.0": { + "sha512": "n9S0XpKv2ruc17FSnaiX6nV47VfHTZ1wLjKZlAirUZCvDQCH71mVp+Ohabn0xXLh5pK2PKp45HCxkqu5Fxn/lA==", + "type": "package", + "path": "System.Reflection.Primitives/4.0.0", + "files": [ + "System.Reflection.Primitives.4.0.0.nupkg.sha512", + "System.Reflection.Primitives.nuspec", + "lib/DNXCore50/System.Reflection.Primitives.dll", + "lib/net45/_._", + "lib/netcore50/System.Reflection.Primitives.dll", + "lib/win8/_._", + "lib/wp80/_._", + "lib/wpa81/_._", + "ref/dotnet/System.Reflection.Primitives.dll", + "ref/dotnet/System.Reflection.Primitives.xml", + "ref/dotnet/de/System.Reflection.Primitives.xml", + "ref/dotnet/es/System.Reflection.Primitives.xml", + "ref/dotnet/fr/System.Reflection.Primitives.xml", + "ref/dotnet/it/System.Reflection.Primitives.xml", + "ref/dotnet/ja/System.Reflection.Primitives.xml", + "ref/dotnet/ko/System.Reflection.Primitives.xml", + "ref/dotnet/ru/System.Reflection.Primitives.xml", + "ref/dotnet/zh-hans/System.Reflection.Primitives.xml", + "ref/dotnet/zh-hant/System.Reflection.Primitives.xml", + "ref/net45/_._", + "ref/netcore50/System.Reflection.Primitives.dll", + "ref/netcore50/System.Reflection.Primitives.xml", + "ref/win8/_._", + "ref/wp80/_._", + "ref/wpa81/_._", + "runtimes/win8-aot/lib/netcore50/System.Reflection.Primitives.dll" + ] + }, + "System.Reflection.TypeExtensions/4.0.0": { + "sha512": "YRM/msNAM86hdxPyXcuZSzmTO0RQFh7YMEPBLTY8cqXvFPYIx2x99bOyPkuU81wRYQem1c1HTkImQ2DjbOBfew==", + "type": "package", + "path": "System.Reflection.TypeExtensions/4.0.0", + "files": [ + "System.Reflection.TypeExtensions.4.0.0.nupkg.sha512", + "System.Reflection.TypeExtensions.nuspec", + "lib/DNXCore50/System.Reflection.TypeExtensions.dll", + "lib/MonoAndroid10/_._", + "lib/MonoTouch10/_._", + "lib/net46/System.Reflection.TypeExtensions.dll", + "lib/netcore50/System.Reflection.TypeExtensions.dll", + "lib/xamarinios10/_._", + "lib/xamarinmac20/_._", + "ref/MonoAndroid10/_._", + "ref/MonoTouch10/_._", + "ref/dotnet/System.Reflection.TypeExtensions.dll", + "ref/dotnet/System.Reflection.TypeExtensions.xml", + "ref/dotnet/de/System.Reflection.TypeExtensions.xml", + "ref/dotnet/es/System.Reflection.TypeExtensions.xml", + "ref/dotnet/fr/System.Reflection.TypeExtensions.xml", + "ref/dotnet/it/System.Reflection.TypeExtensions.xml", + "ref/dotnet/ja/System.Reflection.TypeExtensions.xml", + "ref/dotnet/ko/System.Reflection.TypeExtensions.xml", + "ref/dotnet/ru/System.Reflection.TypeExtensions.xml", + "ref/dotnet/zh-hans/System.Reflection.TypeExtensions.xml", + "ref/dotnet/zh-hant/System.Reflection.TypeExtensions.xml", + "ref/net46/System.Reflection.TypeExtensions.dll", + "ref/xamarinios10/_._", + "ref/xamarinmac20/_._", + "runtimes/win8-aot/lib/netcore50/System.Reflection.TypeExtensions.dll" + ] + }, + "System.Resources.ResourceManager/4.0.0": { + "sha512": "qmqeZ4BJgjfU+G2JbrZt4Dk1LsMxO4t+f/9HarNY6w8pBgweO6jT+cknUH7c3qIrGvyUqraBhU45Eo6UtA0fAw==", + "type": "package", + "path": "System.Resources.ResourceManager/4.0.0", + "files": [ + "System.Resources.ResourceManager.4.0.0.nupkg.sha512", + "System.Resources.ResourceManager.nuspec", + "lib/DNXCore50/System.Resources.ResourceManager.dll", + "lib/net45/_._", + "lib/netcore50/System.Resources.ResourceManager.dll", + "lib/win8/_._", + "lib/wp80/_._", + "lib/wpa81/_._", + "ref/dotnet/System.Resources.ResourceManager.dll", + "ref/dotnet/System.Resources.ResourceManager.xml", + "ref/dotnet/de/System.Resources.ResourceManager.xml", + "ref/dotnet/es/System.Resources.ResourceManager.xml", + "ref/dotnet/fr/System.Resources.ResourceManager.xml", + "ref/dotnet/it/System.Resources.ResourceManager.xml", + "ref/dotnet/ja/System.Resources.ResourceManager.xml", + "ref/dotnet/ko/System.Resources.ResourceManager.xml", + "ref/dotnet/ru/System.Resources.ResourceManager.xml", + "ref/dotnet/zh-hans/System.Resources.ResourceManager.xml", + "ref/dotnet/zh-hant/System.Resources.ResourceManager.xml", + "ref/net45/_._", + "ref/netcore50/System.Resources.ResourceManager.dll", + "ref/netcore50/System.Resources.ResourceManager.xml", + "ref/win8/_._", + "ref/wp80/_._", + "ref/wpa81/_._", + "runtimes/win8-aot/lib/netcore50/System.Resources.ResourceManager.dll" + ] + }, + "System.Runtime/4.0.20": { + "sha512": "X7N/9Bz7jVPorqdVFO86ns1sX6MlQM+WTxELtx+Z4VG45x9+LKmWH0GRqjgKprUnVuwmfB9EJ9DQng14Z7/zwg==", + "type": "package", + "path": "System.Runtime/4.0.20", + "files": [ + "System.Runtime.4.0.20.nupkg.sha512", + "System.Runtime.nuspec", + "lib/DNXCore50/System.Runtime.dll", + "lib/MonoAndroid10/_._", + "lib/MonoTouch10/_._", + "lib/net46/_._", + "lib/netcore50/System.Runtime.dll", + "lib/xamarinios10/_._", + "lib/xamarinmac20/_._", + "ref/MonoAndroid10/_._", + "ref/MonoTouch10/_._", + "ref/dotnet/System.Runtime.dll", + "ref/dotnet/System.Runtime.xml", + "ref/dotnet/de/System.Runtime.xml", + "ref/dotnet/es/System.Runtime.xml", + "ref/dotnet/fr/System.Runtime.xml", + "ref/dotnet/it/System.Runtime.xml", + "ref/dotnet/ja/System.Runtime.xml", + "ref/dotnet/ko/System.Runtime.xml", + "ref/dotnet/ru/System.Runtime.xml", + "ref/dotnet/zh-hans/System.Runtime.xml", + "ref/dotnet/zh-hant/System.Runtime.xml", + "ref/net46/_._", + "ref/xamarinios10/_._", + "ref/xamarinmac20/_._", + "runtimes/win8-aot/lib/netcore50/System.Runtime.dll" + ] + }, + "System.Runtime.Extensions/4.0.10": { + "sha512": "5dsEwf3Iml7d5OZeT20iyOjT+r+okWpN7xI2v+R4cgd3WSj4DeRPTvPFjDpacbVW4skCAZ8B9hxXJYgkCFKJ1A==", + "type": "package", + "path": "System.Runtime.Extensions/4.0.10", + "files": [ + "System.Runtime.Extensions.4.0.10.nupkg.sha512", + "System.Runtime.Extensions.nuspec", + "lib/DNXCore50/System.Runtime.Extensions.dll", + "lib/MonoAndroid10/_._", + "lib/MonoTouch10/_._", + "lib/net46/_._", + "lib/netcore50/System.Runtime.Extensions.dll", + "lib/xamarinios10/_._", + "lib/xamarinmac20/_._", + "ref/MonoAndroid10/_._", + "ref/MonoTouch10/_._", + "ref/dotnet/System.Runtime.Extensions.dll", + "ref/dotnet/System.Runtime.Extensions.xml", + "ref/dotnet/de/System.Runtime.Extensions.xml", + "ref/dotnet/es/System.Runtime.Extensions.xml", + "ref/dotnet/fr/System.Runtime.Extensions.xml", + "ref/dotnet/it/System.Runtime.Extensions.xml", + "ref/dotnet/ja/System.Runtime.Extensions.xml", + "ref/dotnet/ko/System.Runtime.Extensions.xml", + "ref/dotnet/ru/System.Runtime.Extensions.xml", + "ref/dotnet/zh-hans/System.Runtime.Extensions.xml", + "ref/dotnet/zh-hant/System.Runtime.Extensions.xml", + "ref/net46/_._", + "ref/xamarinios10/_._", + "ref/xamarinmac20/_._", + "runtimes/win8-aot/lib/netcore50/System.Runtime.Extensions.dll" + ] + }, + "System.Runtime.Handles/4.0.0": { + "sha512": "638VhpRq63tVcQ6HDb3um3R/J2BtR1Sa96toHo6PcJGPXEPEsleCuqhBgX2gFCz0y0qkutANwW6VPPY5wQu1XQ==", + "type": "package", + "path": "System.Runtime.Handles/4.0.0", + "files": [ + "System.Runtime.Handles.4.0.0.nupkg.sha512", + "System.Runtime.Handles.nuspec", + "lib/DNXCore50/System.Runtime.Handles.dll", + "lib/MonoAndroid10/_._", + "lib/MonoTouch10/_._", + "lib/net46/_._", + "lib/netcore50/System.Runtime.Handles.dll", + "lib/xamarinios10/_._", + "lib/xamarinmac20/_._", + "ref/MonoAndroid10/_._", + "ref/MonoTouch10/_._", + "ref/dotnet/System.Runtime.Handles.dll", + "ref/dotnet/System.Runtime.Handles.xml", + "ref/dotnet/de/System.Runtime.Handles.xml", + "ref/dotnet/es/System.Runtime.Handles.xml", + "ref/dotnet/fr/System.Runtime.Handles.xml", + "ref/dotnet/it/System.Runtime.Handles.xml", + "ref/dotnet/ja/System.Runtime.Handles.xml", + "ref/dotnet/ko/System.Runtime.Handles.xml", + "ref/dotnet/ru/System.Runtime.Handles.xml", + "ref/dotnet/zh-hans/System.Runtime.Handles.xml", + "ref/dotnet/zh-hant/System.Runtime.Handles.xml", + "ref/net46/_._", + "ref/xamarinios10/_._", + "ref/xamarinmac20/_._", + "runtimes/win8-aot/lib/netcore50/System.Runtime.Handles.dll" + ] + }, + "System.Runtime.InteropServices/4.0.20": { + "sha512": "ZgDyBYfEnjWoz/viS6VOswA6XOkDSH2DzgbpczbW50RywhnCgTl+w3JEvtAiOGyIh8cyx1NJq80jsNBSUr8Pig==", + "type": "package", + "path": "System.Runtime.InteropServices/4.0.20", + "files": [ + "System.Runtime.InteropServices.4.0.20.nupkg.sha512", + "System.Runtime.InteropServices.nuspec", + "lib/DNXCore50/System.Runtime.InteropServices.dll", + "lib/MonoAndroid10/_._", + "lib/MonoTouch10/_._", + "lib/net46/_._", + "lib/netcore50/System.Runtime.InteropServices.dll", + "lib/xamarinios10/_._", + "lib/xamarinmac20/_._", + "ref/MonoAndroid10/_._", + "ref/MonoTouch10/_._", + "ref/dotnet/System.Runtime.InteropServices.dll", + "ref/dotnet/System.Runtime.InteropServices.xml", + "ref/dotnet/de/System.Runtime.InteropServices.xml", + "ref/dotnet/es/System.Runtime.InteropServices.xml", + "ref/dotnet/fr/System.Runtime.InteropServices.xml", + "ref/dotnet/it/System.Runtime.InteropServices.xml", + "ref/dotnet/ja/System.Runtime.InteropServices.xml", + "ref/dotnet/ko/System.Runtime.InteropServices.xml", + "ref/dotnet/ru/System.Runtime.InteropServices.xml", + "ref/dotnet/zh-hans/System.Runtime.InteropServices.xml", + "ref/dotnet/zh-hant/System.Runtime.InteropServices.xml", + "ref/net46/_._", + "ref/xamarinios10/_._", + "ref/xamarinmac20/_._", + "runtimes/win8-aot/lib/netcore50/System.Runtime.InteropServices.dll" + ] + }, + "System.Runtime.InteropServices.WindowsRuntime/4.0.0": { + "sha512": "K5MGSvw/sGPKQYdOVqSpsVbHBE8HccHIDEhUNjM1lui65KGF/slNZfijGU87ggQiVXTI802ebKiOYBkwiLotow==", + "type": "package", + "path": "System.Runtime.InteropServices.WindowsRuntime/4.0.0", + "files": [ + "System.Runtime.InteropServices.WindowsRuntime.4.0.0.nupkg.sha512", + "System.Runtime.InteropServices.WindowsRuntime.nuspec", + "lib/net45/_._", + "lib/netcore50/System.Runtime.InteropServices.WindowsRuntime.dll", + "lib/win8/_._", + "lib/wp80/_._", + "lib/wpa81/_._", + "ref/dotnet/System.Runtime.InteropServices.WindowsRuntime.dll", + "ref/dotnet/System.Runtime.InteropServices.WindowsRuntime.xml", + "ref/dotnet/de/System.Runtime.InteropServices.WindowsRuntime.xml", + "ref/dotnet/es/System.Runtime.InteropServices.WindowsRuntime.xml", + "ref/dotnet/fr/System.Runtime.InteropServices.WindowsRuntime.xml", + "ref/dotnet/it/System.Runtime.InteropServices.WindowsRuntime.xml", + "ref/dotnet/ja/System.Runtime.InteropServices.WindowsRuntime.xml", + "ref/dotnet/ko/System.Runtime.InteropServices.WindowsRuntime.xml", + "ref/dotnet/ru/System.Runtime.InteropServices.WindowsRuntime.xml", + "ref/dotnet/zh-hans/System.Runtime.InteropServices.WindowsRuntime.xml", + "ref/dotnet/zh-hant/System.Runtime.InteropServices.WindowsRuntime.xml", + "ref/net45/_._", + "ref/netcore50/System.Runtime.InteropServices.WindowsRuntime.dll", + "ref/netcore50/System.Runtime.InteropServices.WindowsRuntime.xml", + "ref/win8/_._", + "ref/wp80/_._", + "ref/wpa81/_._", + "runtimes/win8-aot/lib/netcore50/System.Runtime.InteropServices.WindowsRuntime.dll" + ] + }, + "System.Runtime.Numerics/4.0.0": { + "sha512": "aAYGEOE01nabQLufQ4YO8WuSyZzOqGcksi8m1BRW8ppkmssR7en8TqiXcBkB2gTkCnKG/Ai2NQY8CgdmgZw/fw==", + "type": "package", + "path": "System.Runtime.Numerics/4.0.0", + "files": [ + "System.Runtime.Numerics.4.0.0.nupkg.sha512", + "System.Runtime.Numerics.nuspec", + "lib/dotnet/System.Runtime.Numerics.dll", + "lib/net45/_._", + "lib/netcore50/System.Runtime.Numerics.dll", + "lib/win8/_._", + "lib/wpa81/_._", + "ref/dotnet/System.Runtime.Numerics.dll", + "ref/dotnet/System.Runtime.Numerics.xml", + "ref/dotnet/de/System.Runtime.Numerics.xml", + "ref/dotnet/es/System.Runtime.Numerics.xml", + "ref/dotnet/fr/System.Runtime.Numerics.xml", + "ref/dotnet/it/System.Runtime.Numerics.xml", + "ref/dotnet/ja/System.Runtime.Numerics.xml", + "ref/dotnet/ko/System.Runtime.Numerics.xml", + "ref/dotnet/ru/System.Runtime.Numerics.xml", + "ref/dotnet/zh-hans/System.Runtime.Numerics.xml", + "ref/dotnet/zh-hant/System.Runtime.Numerics.xml", + "ref/net45/_._", + "ref/netcore50/System.Runtime.Numerics.dll", + "ref/netcore50/System.Runtime.Numerics.xml", + "ref/win8/_._", + "ref/wpa81/_._" + ] + }, + "System.Runtime.WindowsRuntime/4.0.10": { + "sha512": "9w6ypdnEw8RrLRlxTbLAYrap4eL1xIQeNoOaumQVOQ8TTD/5g9FGrBtY3KLiGxAPieN9AwAAEIDkugU85Cwuvg==", + "type": "package", + "path": "System.Runtime.WindowsRuntime/4.0.10", + "files": [ + "System.Runtime.WindowsRuntime.4.0.10.nupkg.sha512", + "System.Runtime.WindowsRuntime.nuspec", + "lib/netcore50/System.Runtime.WindowsRuntime.dll", + "lib/win81/_._", + "lib/wpa81/_._", + "ref/dotnet/System.Runtime.WindowsRuntime.dll", + "ref/dotnet/System.Runtime.WindowsRuntime.xml", + "ref/dotnet/de/System.Runtime.WindowsRuntime.xml", + "ref/dotnet/es/System.Runtime.WindowsRuntime.xml", + "ref/dotnet/fr/System.Runtime.WindowsRuntime.xml", + "ref/dotnet/it/System.Runtime.WindowsRuntime.xml", + "ref/dotnet/ja/System.Runtime.WindowsRuntime.xml", + "ref/dotnet/ko/System.Runtime.WindowsRuntime.xml", + "ref/dotnet/ru/System.Runtime.WindowsRuntime.xml", + "ref/dotnet/zh-hans/System.Runtime.WindowsRuntime.xml", + "ref/dotnet/zh-hant/System.Runtime.WindowsRuntime.xml", + "ref/netcore50/System.Runtime.WindowsRuntime.dll", + "ref/netcore50/System.Runtime.WindowsRuntime.xml", + "ref/win81/_._", + "ref/wpa81/_._", + "runtimes/win8-aot/lib/netcore50/System.Runtime.WindowsRuntime.dll" + ] + }, + "System.Security.Claims/4.0.0": { + "sha512": "94NFR/7JN3YdyTH7hl2iSvYmdA8aqShriTHectcK+EbizT71YczMaG6LuqJBQP/HWo66AQyikYYM9aw+4EzGXg==", + "type": "package", + "path": "System.Security.Claims/4.0.0", + "files": [ + "System.Security.Claims.4.0.0.nupkg.sha512", + "System.Security.Claims.nuspec", + "lib/MonoAndroid10/_._", + "lib/MonoTouch10/_._", + "lib/dotnet/System.Security.Claims.dll", + "lib/net46/System.Security.Claims.dll", + "lib/xamarinios10/_._", + "lib/xamarinmac20/_._", + "ref/MonoAndroid10/_._", + "ref/MonoTouch10/_._", + "ref/dotnet/System.Security.Claims.dll", + "ref/dotnet/System.Security.Claims.xml", + "ref/dotnet/de/System.Security.Claims.xml", + "ref/dotnet/es/System.Security.Claims.xml", + "ref/dotnet/fr/System.Security.Claims.xml", + "ref/dotnet/it/System.Security.Claims.xml", + "ref/dotnet/ja/System.Security.Claims.xml", + "ref/dotnet/ko/System.Security.Claims.xml", + "ref/dotnet/ru/System.Security.Claims.xml", + "ref/dotnet/zh-hans/System.Security.Claims.xml", + "ref/dotnet/zh-hant/System.Security.Claims.xml", + "ref/net46/System.Security.Claims.dll", + "ref/xamarinios10/_._", + "ref/xamarinmac20/_._" + ] + }, + "System.Security.Principal/4.0.0": { + "sha512": "FOhq3jUOONi6fp5j3nPYJMrKtSJlqAURpjiO3FaDIV4DJNEYymWW5uh1pfxySEB8dtAW+I66IypzNge/w9OzZQ==", + "type": "package", + "path": "System.Security.Principal/4.0.0", + "files": [ + "System.Security.Principal.4.0.0.nupkg.sha512", + "System.Security.Principal.nuspec", + "lib/dotnet/System.Security.Principal.dll", + "lib/net45/_._", + "lib/netcore50/System.Security.Principal.dll", + "lib/win8/_._", + "lib/wp80/_._", + "lib/wpa81/_._", + "ref/dotnet/System.Security.Principal.dll", + "ref/dotnet/System.Security.Principal.xml", + "ref/dotnet/de/System.Security.Principal.xml", + "ref/dotnet/es/System.Security.Principal.xml", + "ref/dotnet/fr/System.Security.Principal.xml", + "ref/dotnet/it/System.Security.Principal.xml", + "ref/dotnet/ja/System.Security.Principal.xml", + "ref/dotnet/ko/System.Security.Principal.xml", + "ref/dotnet/ru/System.Security.Principal.xml", + "ref/dotnet/zh-hans/System.Security.Principal.xml", + "ref/dotnet/zh-hant/System.Security.Principal.xml", + "ref/net45/_._", + "ref/netcore50/System.Security.Principal.dll", + "ref/netcore50/System.Security.Principal.xml", + "ref/win8/_._", + "ref/wp80/_._", + "ref/wpa81/_._" + ] + }, + "System.Text.Encoding/4.0.10": { + "sha512": "fNlSFgy4OuDlJrP9SFFxMlaLazq6ipv15sU5TiEgg9UCVnA/OgoVUfymFp4AOk1jOkW5SVxWbeeIUptcM+m/Vw==", + "type": "package", + "path": "System.Text.Encoding/4.0.10", + "files": [ + "System.Text.Encoding.4.0.10.nupkg.sha512", + "System.Text.Encoding.nuspec", + "lib/DNXCore50/System.Text.Encoding.dll", + "lib/MonoAndroid10/_._", + "lib/MonoTouch10/_._", + "lib/net46/_._", + "lib/netcore50/System.Text.Encoding.dll", + "lib/xamarinios10/_._", + "lib/xamarinmac20/_._", + "ref/MonoAndroid10/_._", + "ref/MonoTouch10/_._", + "ref/dotnet/System.Text.Encoding.dll", + "ref/dotnet/System.Text.Encoding.xml", + "ref/dotnet/de/System.Text.Encoding.xml", + "ref/dotnet/es/System.Text.Encoding.xml", + "ref/dotnet/fr/System.Text.Encoding.xml", + "ref/dotnet/it/System.Text.Encoding.xml", + "ref/dotnet/ja/System.Text.Encoding.xml", + "ref/dotnet/ko/System.Text.Encoding.xml", + "ref/dotnet/ru/System.Text.Encoding.xml", + "ref/dotnet/zh-hans/System.Text.Encoding.xml", + "ref/dotnet/zh-hant/System.Text.Encoding.xml", + "ref/net46/_._", + "ref/xamarinios10/_._", + "ref/xamarinmac20/_._", + "runtimes/win8-aot/lib/netcore50/System.Text.Encoding.dll" + ] + }, + "System.Text.Encoding.Extensions/4.0.10": { + "sha512": "TZvlwXMxKo3bSRIcsWZLCIzIhLbvlz+mGeKYRZv/zUiSoQzGOwkYeBu6hOw2XPQgKqT0F4Rv8zqKdvmp2fWKYg==", + "type": "package", + "path": "System.Text.Encoding.Extensions/4.0.10", + "files": [ + "System.Text.Encoding.Extensions.4.0.10.nupkg.sha512", + "System.Text.Encoding.Extensions.nuspec", + "lib/DNXCore50/System.Text.Encoding.Extensions.dll", + "lib/MonoAndroid10/_._", + "lib/MonoTouch10/_._", + "lib/net46/_._", + "lib/netcore50/System.Text.Encoding.Extensions.dll", + "lib/xamarinios10/_._", + "lib/xamarinmac20/_._", + "ref/MonoAndroid10/_._", + "ref/MonoTouch10/_._", + "ref/dotnet/System.Text.Encoding.Extensions.dll", + "ref/dotnet/System.Text.Encoding.Extensions.xml", + "ref/dotnet/de/System.Text.Encoding.Extensions.xml", + "ref/dotnet/es/System.Text.Encoding.Extensions.xml", + "ref/dotnet/fr/System.Text.Encoding.Extensions.xml", + "ref/dotnet/it/System.Text.Encoding.Extensions.xml", + "ref/dotnet/ja/System.Text.Encoding.Extensions.xml", + "ref/dotnet/ko/System.Text.Encoding.Extensions.xml", + "ref/dotnet/ru/System.Text.Encoding.Extensions.xml", + "ref/dotnet/zh-hans/System.Text.Encoding.Extensions.xml", + "ref/dotnet/zh-hant/System.Text.Encoding.Extensions.xml", + "ref/net46/_._", + "ref/xamarinios10/_._", + "ref/xamarinmac20/_._", + "runtimes/win8-aot/lib/netcore50/System.Text.Encoding.Extensions.dll" + ] + }, + "System.Text.RegularExpressions/4.0.10": { + "sha512": "0vDuHXJePpfMCecWBNOabOKCvzfTbFMNcGgklt3l5+RqHV5SzmF7RUVpuet8V0rJX30ROlL66xdehw2Rdsn2DA==", + "type": "package", + "path": "System.Text.RegularExpressions/4.0.10", + "files": [ + "System.Text.RegularExpressions.4.0.10.nupkg.sha512", + "System.Text.RegularExpressions.nuspec", + "lib/MonoAndroid10/_._", + "lib/MonoTouch10/_._", + "lib/dotnet/System.Text.RegularExpressions.dll", + "lib/net46/_._", + "lib/xamarinios10/_._", + "lib/xamarinmac20/_._", + "ref/MonoAndroid10/_._", + "ref/MonoTouch10/_._", + "ref/dotnet/System.Text.RegularExpressions.dll", + "ref/dotnet/System.Text.RegularExpressions.xml", + "ref/dotnet/de/System.Text.RegularExpressions.xml", + "ref/dotnet/es/System.Text.RegularExpressions.xml", + "ref/dotnet/fr/System.Text.RegularExpressions.xml", + "ref/dotnet/it/System.Text.RegularExpressions.xml", + "ref/dotnet/ja/System.Text.RegularExpressions.xml", + "ref/dotnet/ko/System.Text.RegularExpressions.xml", + "ref/dotnet/ru/System.Text.RegularExpressions.xml", + "ref/dotnet/zh-hans/System.Text.RegularExpressions.xml", + "ref/dotnet/zh-hant/System.Text.RegularExpressions.xml", + "ref/net46/_._", + "ref/xamarinios10/_._", + "ref/xamarinmac20/_._" + ] + }, + "System.Threading/4.0.10": { + "sha512": "0w6pRxIEE7wuiOJeKabkDgeIKmqf4ER1VNrs6qFwHnooEE78yHwi/bKkg5Jo8/pzGLm0xQJw0nEmPXt1QBAIUA==", + "type": "package", + "path": "System.Threading/4.0.10", + "files": [ + "System.Threading.4.0.10.nupkg.sha512", + "System.Threading.nuspec", + "lib/DNXCore50/System.Threading.dll", + "lib/MonoAndroid10/_._", + "lib/MonoTouch10/_._", + "lib/net46/_._", + "lib/netcore50/System.Threading.dll", + "lib/xamarinios10/_._", + "lib/xamarinmac20/_._", + "ref/MonoAndroid10/_._", + "ref/MonoTouch10/_._", + "ref/dotnet/System.Threading.dll", + "ref/dotnet/System.Threading.xml", + "ref/dotnet/de/System.Threading.xml", + "ref/dotnet/es/System.Threading.xml", + "ref/dotnet/fr/System.Threading.xml", + "ref/dotnet/it/System.Threading.xml", + "ref/dotnet/ja/System.Threading.xml", + "ref/dotnet/ko/System.Threading.xml", + "ref/dotnet/ru/System.Threading.xml", + "ref/dotnet/zh-hans/System.Threading.xml", + "ref/dotnet/zh-hant/System.Threading.xml", + "ref/net46/_._", + "ref/xamarinios10/_._", + "ref/xamarinmac20/_._", + "runtimes/win8-aot/lib/netcore50/System.Threading.dll" + ] + }, + "System.Threading.Overlapped/4.0.0": { + "sha512": "X5LuQFhM5FTqaez3eXKJ9CbfSGZ7wj6j4hSVtxct3zmwQXLqG95qoWdvILcgN7xtrDOBIFtpiyDg0vmoI0jE2A==", + "type": "package", + "path": "System.Threading.Overlapped/4.0.0", + "files": [ + "System.Threading.Overlapped.4.0.0.nupkg.sha512", + "System.Threading.Overlapped.nuspec", + "lib/DNXCore50/System.Threading.Overlapped.dll", + "lib/net46/System.Threading.Overlapped.dll", + "lib/netcore50/System.Threading.Overlapped.dll", + "ref/dotnet/System.Threading.Overlapped.dll", + "ref/dotnet/System.Threading.Overlapped.xml", + "ref/dotnet/de/System.Threading.Overlapped.xml", + "ref/dotnet/es/System.Threading.Overlapped.xml", + "ref/dotnet/fr/System.Threading.Overlapped.xml", + "ref/dotnet/it/System.Threading.Overlapped.xml", + "ref/dotnet/ja/System.Threading.Overlapped.xml", + "ref/dotnet/ko/System.Threading.Overlapped.xml", + "ref/dotnet/ru/System.Threading.Overlapped.xml", + "ref/dotnet/zh-hans/System.Threading.Overlapped.xml", + "ref/dotnet/zh-hant/System.Threading.Overlapped.xml", + "ref/net46/System.Threading.Overlapped.dll" + ] + }, + "System.Threading.Tasks/4.0.10": { + "sha512": "NOwJGDfk79jR0bnzosbXLVD/PdI8KzBeESoa3CofEM5v9R5EBfcI0Jyf18stx+0IYV9okmDIDxVtxq9TbnR9bQ==", + "type": "package", + "path": "System.Threading.Tasks/4.0.10", + "files": [ + "System.Threading.Tasks.4.0.10.nupkg.sha512", + "System.Threading.Tasks.nuspec", + "lib/DNXCore50/System.Threading.Tasks.dll", + "lib/MonoAndroid10/_._", + "lib/MonoTouch10/_._", + "lib/net46/_._", + "lib/netcore50/System.Threading.Tasks.dll", + "lib/xamarinios10/_._", + "lib/xamarinmac20/_._", + "ref/MonoAndroid10/_._", + "ref/MonoTouch10/_._", + "ref/dotnet/System.Threading.Tasks.dll", + "ref/dotnet/System.Threading.Tasks.xml", + "ref/dotnet/de/System.Threading.Tasks.xml", + "ref/dotnet/es/System.Threading.Tasks.xml", + "ref/dotnet/fr/System.Threading.Tasks.xml", + "ref/dotnet/it/System.Threading.Tasks.xml", + "ref/dotnet/ja/System.Threading.Tasks.xml", + "ref/dotnet/ko/System.Threading.Tasks.xml", + "ref/dotnet/ru/System.Threading.Tasks.xml", + "ref/dotnet/zh-hans/System.Threading.Tasks.xml", + "ref/dotnet/zh-hant/System.Threading.Tasks.xml", + "ref/net46/_._", + "ref/xamarinios10/_._", + "ref/xamarinmac20/_._", + "runtimes/win8-aot/lib/netcore50/System.Threading.Tasks.dll" + ] + }, + "System.Threading.Tasks.Dataflow/4.5.25": { + "sha512": "Y5/Dj+tYlDxHBwie7bFKp3+1uSG4vqTJRF7Zs7kaUQ3ahYClffCTxvgjrJyPclC+Le55uE7bMLgjZQVOQr3Jfg==", + "type": "package", + "path": "System.Threading.Tasks.Dataflow/4.5.25", + "files": [ + "System.Threading.Tasks.Dataflow.4.5.25.nupkg.sha512", + "System.Threading.Tasks.Dataflow.nuspec", + "lib/dotnet/System.Threading.Tasks.Dataflow.XML", + "lib/dotnet/System.Threading.Tasks.Dataflow.dll", + "lib/portable-net45+win8+wp8+wpa81/System.Threading.Tasks.Dataflow.XML", + "lib/portable-net45+win8+wp8+wpa81/System.Threading.Tasks.Dataflow.dll", + "lib/portable-net45+win8+wpa81/System.Threading.Tasks.Dataflow.XML", + "lib/portable-net45+win8+wpa81/System.Threading.Tasks.Dataflow.dll" + ] + }, + "System.Threading.Tasks.Parallel/4.0.0": { + "sha512": "GXDhjPhF3nE4RtDia0W6JR4UMdmhOyt9ibHmsNV6GLRT4HAGqU636Teo4tqvVQOFp2R6b1ffxPXiRaoqtzGxuA==", + "type": "package", + "path": "System.Threading.Tasks.Parallel/4.0.0", + "files": [ + "System.Threading.Tasks.Parallel.4.0.0.nupkg.sha512", + "System.Threading.Tasks.Parallel.nuspec", + "lib/dotnet/System.Threading.Tasks.Parallel.dll", + "lib/net45/_._", + "lib/netcore50/System.Threading.Tasks.Parallel.dll", + "lib/win8/_._", + "lib/wpa81/_._", + "ref/dotnet/System.Threading.Tasks.Parallel.dll", + "ref/dotnet/System.Threading.Tasks.Parallel.xml", + "ref/dotnet/de/System.Threading.Tasks.Parallel.xml", + "ref/dotnet/es/System.Threading.Tasks.Parallel.xml", + "ref/dotnet/fr/System.Threading.Tasks.Parallel.xml", + "ref/dotnet/it/System.Threading.Tasks.Parallel.xml", + "ref/dotnet/ja/System.Threading.Tasks.Parallel.xml", + "ref/dotnet/ko/System.Threading.Tasks.Parallel.xml", + "ref/dotnet/ru/System.Threading.Tasks.Parallel.xml", + "ref/dotnet/zh-hans/System.Threading.Tasks.Parallel.xml", + "ref/dotnet/zh-hant/System.Threading.Tasks.Parallel.xml", + "ref/net45/_._", + "ref/netcore50/System.Threading.Tasks.Parallel.dll", + "ref/netcore50/System.Threading.Tasks.Parallel.xml", + "ref/win8/_._", + "ref/wpa81/_._" + ] + }, + "System.Threading.Timer/4.0.0": { + "sha512": "BIdJH5/e4FnVl7TkRUiE3pWytp7OYiRUGtwUbyLewS/PhKiLepFetdtlW+FvDYOVn60Q2NMTrhHhJ51q+sVW5g==", + "type": "package", + "path": "System.Threading.Timer/4.0.0", + "files": [ + "System.Threading.Timer.4.0.0.nupkg.sha512", + "System.Threading.Timer.nuspec", + "lib/DNXCore50/System.Threading.Timer.dll", + "lib/net451/_._", + "lib/netcore50/System.Threading.Timer.dll", + "lib/win81/_._", + "lib/wpa81/_._", + "ref/dotnet/System.Threading.Timer.dll", + "ref/dotnet/System.Threading.Timer.xml", + "ref/dotnet/de/System.Threading.Timer.xml", + "ref/dotnet/es/System.Threading.Timer.xml", + "ref/dotnet/fr/System.Threading.Timer.xml", + "ref/dotnet/it/System.Threading.Timer.xml", + "ref/dotnet/ja/System.Threading.Timer.xml", + "ref/dotnet/ko/System.Threading.Timer.xml", + "ref/dotnet/ru/System.Threading.Timer.xml", + "ref/dotnet/zh-hans/System.Threading.Timer.xml", + "ref/dotnet/zh-hant/System.Threading.Timer.xml", + "ref/net451/_._", + "ref/netcore50/System.Threading.Timer.dll", + "ref/netcore50/System.Threading.Timer.xml", + "ref/win81/_._", + "ref/wpa81/_._", + "runtimes/win8-aot/lib/netcore50/System.Threading.Timer.dll" + ] + }, + "System.Xml.ReaderWriter/4.0.10": { + "sha512": "VdmWWMH7otrYV7D+cviUo7XjX0jzDnD/lTGSZTlZqfIQ5PhXk85j+6P0TK9od3PnOd5ZIM+pOk01G/J+3nh9/w==", + "type": "package", + "path": "System.Xml.ReaderWriter/4.0.10", + "files": [ + "System.Xml.ReaderWriter.4.0.10.nupkg.sha512", + "System.Xml.ReaderWriter.nuspec", + "lib/MonoAndroid10/_._", + "lib/MonoTouch10/_._", + "lib/dotnet/System.Xml.ReaderWriter.dll", + "lib/net46/_._", + "lib/xamarinios10/_._", + "lib/xamarinmac20/_._", + "ref/MonoAndroid10/_._", + "ref/MonoTouch10/_._", + "ref/dotnet/System.Xml.ReaderWriter.dll", + "ref/dotnet/System.Xml.ReaderWriter.xml", + "ref/dotnet/de/System.Xml.ReaderWriter.xml", + "ref/dotnet/es/System.Xml.ReaderWriter.xml", + "ref/dotnet/fr/System.Xml.ReaderWriter.xml", + "ref/dotnet/it/System.Xml.ReaderWriter.xml", + "ref/dotnet/ja/System.Xml.ReaderWriter.xml", + "ref/dotnet/ko/System.Xml.ReaderWriter.xml", + "ref/dotnet/ru/System.Xml.ReaderWriter.xml", + "ref/dotnet/zh-hans/System.Xml.ReaderWriter.xml", + "ref/dotnet/zh-hant/System.Xml.ReaderWriter.xml", + "ref/net46/_._", + "ref/xamarinios10/_._", + "ref/xamarinmac20/_._" + ] + }, + "System.Xml.XDocument/4.0.10": { + "sha512": "+ej0g0INnXDjpS2tDJsLO7/BjyBzC+TeBXLeoGnvRrm4AuBH9PhBjjZ1IuKWOhCkxPkFognUOKhZHS2glIOlng==", + "type": "package", + "path": "System.Xml.XDocument/4.0.10", + "files": [ + "System.Xml.XDocument.4.0.10.nupkg.sha512", + "System.Xml.XDocument.nuspec", + "lib/MonoAndroid10/_._", + "lib/MonoTouch10/_._", + "lib/dotnet/System.Xml.XDocument.dll", + "lib/net46/_._", + "lib/xamarinios10/_._", + "lib/xamarinmac20/_._", + "ref/MonoAndroid10/_._", + "ref/MonoTouch10/_._", + "ref/dotnet/System.Xml.XDocument.dll", + "ref/dotnet/System.Xml.XDocument.xml", + "ref/dotnet/de/System.Xml.XDocument.xml", + "ref/dotnet/es/System.Xml.XDocument.xml", + "ref/dotnet/fr/System.Xml.XDocument.xml", + "ref/dotnet/it/System.Xml.XDocument.xml", + "ref/dotnet/ja/System.Xml.XDocument.xml", + "ref/dotnet/ko/System.Xml.XDocument.xml", + "ref/dotnet/ru/System.Xml.XDocument.xml", + "ref/dotnet/zh-hans/System.Xml.XDocument.xml", + "ref/dotnet/zh-hant/System.Xml.XDocument.xml", + "ref/net46/_._", + "ref/xamarinios10/_._", + "ref/xamarinmac20/_._" + ] + } + }, + "projectFileDependencyGroups": { + "": [ + "Microsoft.NETCore >= 5.0.0", + "Microsoft.NETCore.Portable.Compatibility >= 1.0.0" + ], + ".NETPlatform,Version=v5.0": [] + }, + "tools": {}, + "projectFileToolGroups": {} +} \ No newline at end of file diff --git a/DvdLib/BigEndianBinaryReader.cs b/DvdLib/BigEndianBinaryReader.cs new file mode 100644 index 0000000000..56d9db8255 --- /dev/null +++ b/DvdLib/BigEndianBinaryReader.cs @@ -0,0 +1,33 @@ +using System; +using System.Collections.Generic; +using System.Linq; +using System.Text; +using System.IO; + +namespace DvdLib +{ + public class BigEndianBinaryReader : BinaryReader + { + public BigEndianBinaryReader(Stream input) + : base(input) + { + } + + public override ushort ReadUInt16() + { + return BitConverter.ToUInt16(ReadAndReverseBytes(2), 0); + } + + public override uint ReadUInt32() + { + return BitConverter.ToUInt32(ReadAndReverseBytes(4), 0); + } + + private byte[] ReadAndReverseBytes(int count) + { + byte[] val = base.ReadBytes(count); + Array.Reverse(val, 0, count); + return val; + } + } +} diff --git a/DvdLib/DvdLib.csproj b/DvdLib/DvdLib.csproj new file mode 100644 index 0000000000..8545e8d98f --- /dev/null +++ b/DvdLib/DvdLib.csproj @@ -0,0 +1,76 @@ + + + + + 11.0 + Debug + AnyCPU + {713F42B5-878E-499D-A878-E4C652B1D5E8} + Library + Properties + DvdLib + DvdLib + en-US + 512 + {786C830F-07A1-408B-BD7F-6EE04809D6DB};{FAE04EC0-301F-11D3-BF4B-00C04F79EFBC} + Profile7 + v4.5 + + + true + full + false + bin\Debug\ + DEBUG;TRACE + prompt + 4 + + + pdbonly + true + bin\Release\ + TRACE + prompt + 4 + + + + + + + + + + + + + + + + + + + + + + + + + {7eeeb4bb-f3e8-48fc-b4c5-70f0fff8329b} + MediaBrowser.Model + + + + + if $(ConfigurationName) == Release ( +xcopy "$(TargetPath)" "$(SolutionDir)\Nuget\dlls\" /y /d /r /i +) + + + \ No newline at end of file diff --git a/DvdLib/DvdLib.nuget.targets b/DvdLib/DvdLib.nuget.targets new file mode 100644 index 0000000000..e69ce0e64f --- /dev/null +++ b/DvdLib/DvdLib.nuget.targets @@ -0,0 +1,6 @@ + + + + + + \ No newline at end of file diff --git a/DvdLib/Ifo/AudioAttributes.cs b/DvdLib/Ifo/AudioAttributes.cs new file mode 100644 index 0000000000..5b3b9fd9a0 --- /dev/null +++ b/DvdLib/Ifo/AudioAttributes.cs @@ -0,0 +1,41 @@ +using System; +using System.Collections.Generic; +using System.Linq; +using System.Text; + +namespace DvdLib.Ifo +{ + public enum AudioCodec + { + AC3 = 0, + MPEG1 = 2, + MPEG2ext = 3, + LPCM = 4, + DTS = 6, + } + + public enum ApplicationMode + { + Unspecified = 0, + Karaoke = 1, + Surround = 2, + } + + public class AudioAttributes + { + public readonly AudioCodec Codec; + public readonly bool MultichannelExtensionPresent; + public readonly ApplicationMode Mode; + public readonly byte QuantDRC; + public readonly byte SampleRate; + public readonly byte Channels; + public readonly ushort LanguageCode; + public readonly byte LanguageExtension; + public readonly byte CodeExtension; + } + + public class MultiChannelExtension + { + + } +} diff --git a/DvdLib/Ifo/Cell.cs b/DvdLib/Ifo/Cell.cs new file mode 100644 index 0000000000..d0f442e362 --- /dev/null +++ b/DvdLib/Ifo/Cell.cs @@ -0,0 +1,24 @@ +using System; +using System.Collections.Generic; +using System.Linq; +using System.Text; +using System.IO; + +namespace DvdLib.Ifo +{ + public class Cell + { + public CellPlaybackInfo PlaybackInfo { get; private set; } + public CellPositionInfo PositionInfo { get; private set; } + + internal void ParsePlayback(BinaryReader br) + { + PlaybackInfo = new CellPlaybackInfo(br); + } + + internal void ParsePosition(BinaryReader br) + { + PositionInfo = new CellPositionInfo(br); + } + } +} diff --git a/DvdLib/Ifo/CellPlaybackInfo.cs b/DvdLib/Ifo/CellPlaybackInfo.cs new file mode 100644 index 0000000000..ae3883eaa0 --- /dev/null +++ b/DvdLib/Ifo/CellPlaybackInfo.cs @@ -0,0 +1,54 @@ +using System; +using System.Collections.Generic; +using System.Linq; +using System.Text; +using System.IO; + +namespace DvdLib.Ifo +{ + public enum BlockMode + { + NotInBlock = 0, + FirstCell = 1, + InBlock = 2, + LastCell = 3, + } + + public enum BlockType + { + Normal = 0, + Angle = 1, + } + + public enum PlaybackMode + { + Normal = 0, + StillAfterEachVOBU = 1, + } + + public class CellPlaybackInfo + { + public readonly BlockMode Mode; + public readonly BlockType Type; + public readonly bool SeamlessPlay; + public readonly bool Interleaved; + public readonly bool STCDiscontinuity; + public readonly bool SeamlessAngle; + public readonly PlaybackMode PlaybackMode; + public readonly bool Restricted; + public readonly byte StillTime; + public readonly byte CommandNumber; + public readonly DvdTime PlaybackTime; + public readonly uint FirstSector; + public readonly uint FirstILVUEndSector; + public readonly uint LastVOBUStartSector; + public readonly uint LastSector; + + internal CellPlaybackInfo(BinaryReader br) + { + br.BaseStream.Seek(0x4, SeekOrigin.Current); + PlaybackTime = new DvdTime(br.ReadBytes(4)); + br.BaseStream.Seek(0x10, SeekOrigin.Current); + } + } +} diff --git a/DvdLib/Ifo/CellPositionInfo.cs b/DvdLib/Ifo/CellPositionInfo.cs new file mode 100644 index 0000000000..2e07159402 --- /dev/null +++ b/DvdLib/Ifo/CellPositionInfo.cs @@ -0,0 +1,21 @@ +using System; +using System.Collections.Generic; +using System.Linq; +using System.Text; +using System.IO; + +namespace DvdLib.Ifo +{ + public class CellPositionInfo + { + public readonly ushort VOBId; + public readonly byte CellId; + + internal CellPositionInfo(BinaryReader br) + { + VOBId = br.ReadUInt16(); + br.ReadByte(); + CellId = br.ReadByte(); + } + } +} diff --git a/DvdLib/Ifo/Chapter.cs b/DvdLib/Ifo/Chapter.cs new file mode 100644 index 0000000000..802c6ce62a --- /dev/null +++ b/DvdLib/Ifo/Chapter.cs @@ -0,0 +1,21 @@ +using System; +using System.Collections.Generic; +using System.Linq; +using System.Text; + +namespace DvdLib.Ifo +{ + public class Chapter + { + public ushort ProgramChainNumber { get; private set; } + public ushort ProgramNumber { get; private set; } + public uint ChapterNumber { get; private set; } + + public Chapter(ushort pgcNum, ushort programNum, uint chapterNum) + { + ProgramChainNumber = pgcNum; + ProgramNumber = programNum; + ChapterNumber = chapterNum; + } + } +} diff --git a/DvdLib/Ifo/Dvd.cs b/DvdLib/Ifo/Dvd.cs new file mode 100644 index 0000000000..508c23db45 --- /dev/null +++ b/DvdLib/Ifo/Dvd.cs @@ -0,0 +1,161 @@ +using System; +using System.Collections.Generic; +using System.Linq; +using System.Text; +using System.IO; +using System.Diagnostics; +using MediaBrowser.Model.IO; + +namespace DvdLib.Ifo +{ + public class Dvd + { + private readonly ushort _titleSetCount; + public readonly List Titles; + + private ushort _titleCount; + public readonly Dictionary<ushort, string> VTSPaths = new Dictionary<ushort, string>(); + private readonly IFileSystem _fileSystem; + + public Dvd(string path, IFileSystem fileSystem) + { + _fileSystem = fileSystem; + Titles = new List<Title>(); + var allFiles = _fileSystem.GetFiles(path, true).ToList(); + + var vmgPath = allFiles.FirstOrDefault(i => string.Equals(i.Name, "VIDEO_TS.IFO", StringComparison.OrdinalIgnoreCase)) ?? + allFiles.FirstOrDefault(i => string.Equals(i.Name, "VIDEO_TS.BUP", StringComparison.OrdinalIgnoreCase)); + + if (vmgPath == null) + { + var allIfos = allFiles.Where(i => string.Equals(i.Extension, ".ifo", StringComparison.OrdinalIgnoreCase)); + + foreach (var ifo in allIfos) + { + var num = ifo.Name.Split('_').ElementAtOrDefault(1); + ushort ifoNumber; + var numbersRead = new List<ushort>(); + + if (!string.IsNullOrEmpty(num) && ushort.TryParse(num, out ifoNumber) && !numbersRead.Contains(ifoNumber)) + { + ReadVTS(ifoNumber, ifo.FullName); + numbersRead.Add(ifoNumber); + } + } + } + else + { + using (var vmgFs = _fileSystem.GetFileStream(vmgPath.FullName, FileOpenMode.Open, FileAccessMode.Read, FileShareMode.Read)) + { + using (BigEndianBinaryReader vmgRead = new BigEndianBinaryReader(vmgFs)) + { + vmgFs.Seek(0x3E, SeekOrigin.Begin); + _titleSetCount = vmgRead.ReadUInt16(); + + // read address of TT_SRPT + vmgFs.Seek(0xC4, SeekOrigin.Begin); + uint ttSectorPtr = vmgRead.ReadUInt32(); + vmgFs.Seek(ttSectorPtr * 2048, SeekOrigin.Begin); + ReadTT_SRPT(vmgRead); + } + } + + for (ushort titleSetNum = 1; titleSetNum <= _titleSetCount; titleSetNum++) + { + ReadVTS(titleSetNum, allFiles); + } + } + } + + private void ReadTT_SRPT(BinaryReader read) + { + _titleCount = read.ReadUInt16(); + read.BaseStream.Seek(6, SeekOrigin.Current); + for (uint titleNum = 1; titleNum <= _titleCount; titleNum++) + { + Title t = new Title(titleNum); + t.ParseTT_SRPT(read); + Titles.Add(t); + } + } + + private void ReadVTS(ushort vtsNum, List<FileSystemMetadata> allFiles) + { + var filename = String.Format("VTS_{0:00}_0.IFO", vtsNum); + + var vtsPath = allFiles.FirstOrDefault(i => string.Equals(i.Name, filename, StringComparison.OrdinalIgnoreCase)) ?? + allFiles.FirstOrDefault(i => string.Equals(i.Name, Path.ChangeExtension(filename, ".bup"), StringComparison.OrdinalIgnoreCase)); + + if (vtsPath == null) + { + throw new FileNotFoundException("Unable to find VTS IFO file"); + } + + ReadVTS(vtsNum, vtsPath.FullName); + } + + private void ReadVTS(ushort vtsNum, string vtsPath) + { + VTSPaths[vtsNum] = vtsPath; + + using (var vtsFs = _fileSystem.GetFileStream(vtsPath, FileOpenMode.Open, FileAccessMode.Read, FileShareMode.Read)) + { + using (BigEndianBinaryReader vtsRead = new BigEndianBinaryReader(vtsFs)) + { + // Read VTS_PTT_SRPT + vtsFs.Seek(0xC8, SeekOrigin.Begin); + uint vtsPttSrptSecPtr = vtsRead.ReadUInt32(); + uint baseAddr = (vtsPttSrptSecPtr * 2048); + vtsFs.Seek(baseAddr, SeekOrigin.Begin); + + ushort numTitles = vtsRead.ReadUInt16(); + vtsRead.ReadUInt16(); + uint endaddr = vtsRead.ReadUInt32(); + uint[] offsets = new uint[numTitles]; + for (ushort titleNum = 0; titleNum < numTitles; titleNum++) + { + offsets[titleNum] = vtsRead.ReadUInt32(); + } + + for (uint titleNum = 0; titleNum < numTitles; titleNum++) + { + uint chapNum = 1; + vtsFs.Seek(baseAddr + offsets[titleNum], SeekOrigin.Begin); + Title t = Titles.FirstOrDefault(vtst => vtst.IsVTSTitle(vtsNum, titleNum + 1)); + if (t == null) continue; + + do + { + t.Chapters.Add(new Chapter(vtsRead.ReadUInt16(), vtsRead.ReadUInt16(), chapNum)); + if (titleNum + 1 < numTitles && vtsFs.Position == (baseAddr + offsets[titleNum + 1])) break; + chapNum++; + } + while (vtsFs.Position < (baseAddr + endaddr)); + } + + // Read VTS_PGCI + vtsFs.Seek(0xCC, SeekOrigin.Begin); + uint vtsPgciSecPtr = vtsRead.ReadUInt32(); + vtsFs.Seek(vtsPgciSecPtr * 2048, SeekOrigin.Begin); + + long startByte = vtsFs.Position; + + ushort numPgcs = vtsRead.ReadUInt16(); + vtsFs.Seek(6, SeekOrigin.Current); + for (ushort pgcNum = 1; pgcNum <= numPgcs; pgcNum++) + { + byte pgcCat = vtsRead.ReadByte(); + bool entryPgc = (pgcCat & 0x80) != 0; + uint titleNum = (uint)(pgcCat & 0x7F); + + vtsFs.Seek(3, SeekOrigin.Current); + uint vtsPgcOffset = vtsRead.ReadUInt32(); + + Title t = Titles.FirstOrDefault(vtst => vtst.IsVTSTitle(vtsNum, titleNum)); + if (t != null) t.AddPgc(vtsRead, startByte + vtsPgcOffset, entryPgc, pgcNum); + } + } + } + } + } +} \ No newline at end of file diff --git a/DvdLib/Ifo/DvdTime.cs b/DvdLib/Ifo/DvdTime.cs new file mode 100644 index 0000000000..f565f5fdf7 --- /dev/null +++ b/DvdLib/Ifo/DvdTime.cs @@ -0,0 +1,34 @@ +using System; +using System.Collections.Generic; +using System.Linq; +using System.Text; + +namespace DvdLib.Ifo +{ + public class DvdTime + { + public readonly byte Hour, Minute, Second, Frames, FrameRate; + + public DvdTime(byte[] data) + { + Hour = GetBCDValue(data[0]); + Minute = GetBCDValue(data[1]); + Second = GetBCDValue(data[2]); + Frames = GetBCDValue((byte)(data[3] & 0x3F)); + + if ((data[3] & 0x80) != 0) FrameRate = 30; + else if ((data[3] & 0x40) != 0) FrameRate = 25; + } + + private byte GetBCDValue(byte data) + { + return (byte)((((data & 0xF0) >> 4) * 10) + (data & 0x0F)); + } + + public static explicit operator TimeSpan(DvdTime time) + { + int ms = (int)(((1.0 / (double)time.FrameRate) * time.Frames) * 1000.0); + return new TimeSpan(0, time.Hour, time.Minute, time.Second, ms); + } + } +} diff --git a/DvdLib/Ifo/PgcCommandTable.cs b/DvdLib/Ifo/PgcCommandTable.cs new file mode 100644 index 0000000000..2ead78cef9 --- /dev/null +++ b/DvdLib/Ifo/PgcCommandTable.cs @@ -0,0 +1,20 @@ +using System; +using System.Collections.Generic; +using System.Linq; +using System.Text; + +namespace DvdLib.Ifo +{ + public class ProgramChainCommandTable + { + public readonly ushort LastByteAddress; + public readonly List<VirtualMachineCommand> PreCommands; + public readonly List<VirtualMachineCommand> PostCommands; + public readonly List<VirtualMachineCommand> CellCommands; + } + + public class VirtualMachineCommand + { + public readonly byte[] Command; + } +} diff --git a/DvdLib/Ifo/Program.cs b/DvdLib/Ifo/Program.cs new file mode 100644 index 0000000000..48870d9dd0 --- /dev/null +++ b/DvdLib/Ifo/Program.cs @@ -0,0 +1,17 @@ +using System; +using System.Collections.Generic; +using System.Linq; +using System.Text; + +namespace DvdLib.Ifo +{ + public class Program + { + public readonly List<Cell> Cells; + + public Program(List<Cell> cells) + { + Cells = cells; + } + } +} diff --git a/DvdLib/Ifo/ProgramChain.cs b/DvdLib/Ifo/ProgramChain.cs new file mode 100644 index 0000000000..3179f73cd6 --- /dev/null +++ b/DvdLib/Ifo/ProgramChain.cs @@ -0,0 +1,117 @@ +using System; +using System.Collections.Generic; +using System.Linq; +using System.Text; +using System.IO; + +namespace DvdLib.Ifo +{ + public enum ProgramPlaybackMode + { + Sequential, + Random, + Shuffle + } + + public class ProgramChain + { + private ushort _unknown1; + + private byte _programCount; + public readonly List<Program> Programs; + + private byte _cellCount; + public readonly List<Cell> Cells; + + public DvdTime PlaybackTime { get; private set; } + public UserOperation ProhibitedUserOperations { get; private set; } + public byte[] AudioStreamControl { get; private set; } // 8*2 entries + public byte[] SubpictureStreamControl { get; private set; } // 32*4 entries + + private ushort _nextProgramNumber; + public readonly ProgramChain Next; + + private ushort _prevProgramNumber; + public readonly ProgramChain Previous; + + private ushort _goupProgramNumber; + public readonly ProgramChain Goup; // ?? maybe Group + + private byte _playbackMode; + public ProgramPlaybackMode PlaybackMode { get; private set; } + public uint ProgramCount { get; private set; } + + public byte StillTime { get; private set; } + public byte[] Palette { get; private set; } // 16*4 entries + + private ushort _commandTableOffset; + public readonly ProgramChainCommandTable CommandTable; + + private ushort _programMapOffset; + private ushort _cellPlaybackOffset; + private ushort _cellPositionOffset; + + public readonly uint VideoTitleSetIndex; + + internal ProgramChain(uint vtsPgcNum) + { + VideoTitleSetIndex = vtsPgcNum; + Cells = new List<Cell>(); + Programs = new List<Program>(); + } + + internal void ParseHeader(BinaryReader br) + { + long startPos = br.BaseStream.Position; + + br.ReadUInt16(); + _programCount = br.ReadByte(); + _cellCount = br.ReadByte(); + PlaybackTime = new DvdTime(br.ReadBytes(4)); + ProhibitedUserOperations = (UserOperation)br.ReadUInt32(); + AudioStreamControl = br.ReadBytes(16); + SubpictureStreamControl = br.ReadBytes(128); + + _nextProgramNumber = br.ReadUInt16(); + _prevProgramNumber = br.ReadUInt16(); + _goupProgramNumber = br.ReadUInt16(); + + StillTime = br.ReadByte(); + byte pbMode = br.ReadByte(); + if (pbMode == 0) PlaybackMode = ProgramPlaybackMode.Sequential; + else PlaybackMode = ((pbMode & 0x80) == 0) ? ProgramPlaybackMode.Random : ProgramPlaybackMode.Shuffle; + ProgramCount = (uint)(pbMode & 0x7F); + + Palette = br.ReadBytes(64); + _commandTableOffset = br.ReadUInt16(); + _programMapOffset = br.ReadUInt16(); + _cellPlaybackOffset = br.ReadUInt16(); + _cellPositionOffset = br.ReadUInt16(); + + // read position info + br.BaseStream.Seek(startPos + _cellPositionOffset, SeekOrigin.Begin); + for (int cellNum = 0; cellNum < _cellCount; cellNum++) + { + Cell c = new Cell(); + c.ParsePosition(br); + Cells.Add(c); + } + + br.BaseStream.Seek(startPos + _cellPlaybackOffset, SeekOrigin.Begin); + for (int cellNum = 0; cellNum < _cellCount; cellNum++) + { + Cells[cellNum].ParsePlayback(br); + } + + br.BaseStream.Seek(startPos + _programMapOffset, SeekOrigin.Begin); + List<int> cellNumbers = new List<int>(); + for (int progNum = 0; progNum < _programCount; progNum++) cellNumbers.Add(br.ReadByte() - 1); + + for (int i = 0; i < cellNumbers.Count; i++) + { + int max = (i + 1 == cellNumbers.Count) ? _cellCount : cellNumbers[i+1]; + Programs.Add(new Program(Cells.Where((c, idx) => idx >= cellNumbers[i] && idx < max).ToList())); + } + } + } +} diff --git a/DvdLib/Ifo/Title.cs b/DvdLib/Ifo/Title.cs new file mode 100644 index 0000000000..70deb45bfa --- /dev/null +++ b/DvdLib/Ifo/Title.cs @@ -0,0 +1,64 @@ +using System; +using System.Collections.Generic; +using System.Linq; +using System.Text; +using System.IO; + +namespace DvdLib.Ifo +{ + public class Title + { + public uint TitleNumber { get; private set; } + public uint AngleCount { get; private set; } + public ushort ChapterCount { get; private set; } + public byte VideoTitleSetNumber { get; private set; } + + private ushort _parentalManagementMask; + private byte _titleNumberInVTS; + private uint _vtsStartSector; // relative to start of entire disk + + public ProgramChain EntryProgramChain { get; private set; } + public readonly List<ProgramChain> ProgramChains; + + public readonly List<Chapter> Chapters; + + public Title(uint titleNum) + { + ProgramChains = new List<ProgramChain>(); + Chapters = new List<Chapter>(); + Chapters = new List<Chapter>(); + TitleNumber = titleNum; + } + + public bool IsVTSTitle(uint vtsNum, uint vtsTitleNum) + { + return (vtsNum == VideoTitleSetNumber && vtsTitleNum == _titleNumberInVTS); + } + + internal void ParseTT_SRPT(BinaryReader br) + { + byte titleType = br.ReadByte(); + // TODO parse Title Type + + AngleCount = br.ReadByte(); + ChapterCount = br.ReadUInt16(); + _parentalManagementMask = br.ReadUInt16(); + VideoTitleSetNumber = br.ReadByte(); + _titleNumberInVTS = br.ReadByte(); + _vtsStartSector = br.ReadUInt32(); + } + + internal void AddPgc(BinaryReader br, long startByte, bool entryPgc, uint pgcNum) + { + long curPos = br.BaseStream.Position; + br.BaseStream.Seek(startByte, SeekOrigin.Begin); + + ProgramChain pgc = new ProgramChain(pgcNum); + pgc.ParseHeader(br); + ProgramChains.Add(pgc); + if (entryPgc) EntryProgramChain = pgc; + + br.BaseStream.Seek(curPos, SeekOrigin.Begin); + } + } +} diff --git a/DvdLib/Ifo/UserOperation.cs b/DvdLib/Ifo/UserOperation.cs new file mode 100644 index 0000000000..c3cffd4870 --- /dev/null +++ b/DvdLib/Ifo/UserOperation.cs @@ -0,0 +1,38 @@ +using System; +using System.Collections.Generic; +using System.Linq; +using System.Text; + +namespace DvdLib.Ifo +{ + [Flags] + public enum UserOperation + { + None = 0, + TitleOrTimePlay = 1, + ChapterSearchOrPlay = 2, + TitlePlay = 4, + Stop = 8, + GoUp = 16, + TimeOrChapterSearch = 32, + PrevOrTopProgramSearch = 64, + NextProgramSearch = 128, + ForwardScan = 256, + BackwardScan = 512, + TitleMenuCall = 1024, + RootMenuCall = 2048, + SubpictureMenuCall = 4096, + AudioMenuCall = 8192, + AngleMenuCall = 16384, + ChapterMenuCall = 32768, + Resume = 65536, + ButtonSelectOrActive = 131072, + StillOff = 262144, + PauseOn = 524288, + AudioStreamChange = 1048576, + SubpictureStreamChange = 2097152, + AngleChange = 4194304, + KaraokeAudioPresentationModeChange = 8388608, + VideoPresentationModeChange = 16777216, + } +} diff --git a/DvdLib/Ifo/VideoAttributes.cs b/DvdLib/Ifo/VideoAttributes.cs new file mode 100644 index 0000000000..b2d3759426 --- /dev/null +++ b/DvdLib/Ifo/VideoAttributes.cs @@ -0,0 +1,51 @@ +using System; +using System.Collections.Generic; +using System.Linq; +using System.Text; + +namespace DvdLib.Ifo +{ + public enum VideoCodec + { + MPEG1 = 0, + MPEG2 = 1, + } + + public enum VideoFormat + { + NTSC = 0, + PAL = 1, + } + + public enum AspectRatio + { + ar4to3 = 0, + ar16to9 = 3 + } + + public enum FilmMode + { + None = -1, + Camera = 0, + Film = 1, + } + + public class VideoAttributes + { + public readonly VideoCodec Codec; + public readonly VideoFormat Format; + public readonly AspectRatio Aspect; + public readonly bool AutomaticPanScan; + public readonly bool AutomaticLetterBox; + public readonly bool Line21CCField1; + public readonly bool Line21CCField2; + public readonly int Width; + public readonly int Height; + public readonly bool Letterboxed; + public readonly FilmMode FilmMode; + + public VideoAttributes() + { + } + } +} diff --git a/DvdLib/Properties/AssemblyInfo.cs b/DvdLib/Properties/AssemblyInfo.cs new file mode 100644 index 0000000000..cca792684f --- /dev/null +++ b/DvdLib/Properties/AssemblyInfo.cs @@ -0,0 +1,29 @@ +using System.Resources; +using System.Reflection; +using System.Runtime.CompilerServices; +using System.Runtime.InteropServices; + +// General Information about an assembly is controlled through the following +// set of attributes. Change these attribute values to modify the information +// associated with an assembly. +[assembly: AssemblyTitle("DvdLib")] +[assembly: AssemblyDescription("")] +[assembly: AssemblyConfiguration("")] +[assembly: AssemblyCompany("")] +[assembly: AssemblyProduct("DvdLib")] +[assembly: AssemblyCopyright("Copyright © 2016")] +[assembly: AssemblyTrademark("")] +[assembly: AssemblyCulture("")] +[assembly: NeutralResourcesLanguage("en")] + +// Version information for an assembly consists of the following four values: +// +// Major Version +// Minor Version +// Build Number +// Revision +// +// You can specify all the values or you can default the Build and Revision Numbers +// by using the '*' as shown below: +// [assembly: AssemblyVersion("1.0.*")] +[assembly: AssemblyVersion("1.0.1")] \ No newline at end of file diff --git a/DvdLib/project.json b/DvdLib/project.json new file mode 100644 index 0000000000..9d20d9ec9c --- /dev/null +++ b/DvdLib/project.json @@ -0,0 +1,16 @@ +{ + "frameworks": { + "netstandard1.6": { + "dependencies": { + "NETStandard.Library": "1.6.0" + } + }, + ".NETPortable,Version=v4.5,Profile=Profile7": { + "buildOptions": { + "define": [] + }, + "frameworkAssemblies": {} + } + }, + "dependencies": {} +} \ No newline at end of file diff --git a/DvdLib/project.lock.json b/DvdLib/project.lock.json new file mode 100644 index 0000000000..a42f93878d --- /dev/null +++ b/DvdLib/project.lock.json @@ -0,0 +1,3965 @@ +{ + "locked": false, + "version": 1, + "targets": { + ".NETPortable,Version=v4.5,Profile=Profile7": {}, + ".NETStandard,Version=v1.6": { + "Microsoft.NETCore.Platforms/1.0.1": { + "compile": { + "lib/netstandard1.0/_._": {} + }, + "runtime": { + "lib/netstandard1.0/_._": {} + } + }, + "Microsoft.NETCore.Targets/1.0.1": { + "compile": { + "lib/netstandard1.0/_._": {} + }, + "runtime": { + "lib/netstandard1.0/_._": {} + } + }, + "Microsoft.Win32.Primitives/4.0.1": { + "dependencies": { + "Microsoft.NETCore.Platforms": "1.0.1", + "Microsoft.NETCore.Targets": "1.0.1", + "System.Runtime": "4.1.0" + }, + "compile": { + "ref/netstandard1.3/Microsoft.Win32.Primitives.dll": {} + } + }, + "NETStandard.Library/1.6.0": { + "dependencies": { + "Microsoft.NETCore.Platforms": "1.0.1", + "Microsoft.Win32.Primitives": "4.0.1", + "System.AppContext": "4.1.0", + "System.Collections": "4.0.11", + "System.Collections.Concurrent": "4.0.12", + "System.Console": "4.0.0", + "System.Diagnostics.Debug": "4.0.11", + "System.Diagnostics.Tools": "4.0.1", + "System.Diagnostics.Tracing": "4.1.0", + "System.Globalization": "4.0.11", + "System.Globalization.Calendars": "4.0.1", + "System.IO": "4.1.0", + "System.IO.Compression": "4.1.0", + "System.IO.Compression.ZipFile": "4.0.1", + "System.IO.FileSystem": "4.0.1", + "System.IO.FileSystem.Primitives": "4.0.1", + "System.Linq": "4.1.0", + "System.Linq.Expressions": "4.1.0", + "System.Net.Http": "4.1.0", + "System.Net.Primitives": "4.0.11", + "System.Net.Sockets": "4.1.0", + "System.ObjectModel": "4.0.12", + "System.Reflection": "4.1.0", + "System.Reflection.Extensions": "4.0.1", + "System.Reflection.Primitives": "4.0.1", + "System.Resources.ResourceManager": "4.0.1", + "System.Runtime": "4.1.0", + "System.Runtime.Extensions": "4.1.0", + "System.Runtime.Handles": "4.0.1", + "System.Runtime.InteropServices": "4.1.0", + "System.Runtime.InteropServices.RuntimeInformation": "4.0.0", + "System.Runtime.Numerics": "4.0.1", + "System.Security.Cryptography.Algorithms": "4.2.0", + "System.Security.Cryptography.Encoding": "4.0.0", + "System.Security.Cryptography.Primitives": "4.0.0", + "System.Security.Cryptography.X509Certificates": "4.1.0", + "System.Text.Encoding": "4.0.11", + "System.Text.Encoding.Extensions": "4.0.11", + "System.Text.RegularExpressions": "4.1.0", + "System.Threading": "4.0.11", + "System.Threading.Tasks": "4.0.11", + "System.Threading.Timer": "4.0.1", + "System.Xml.ReaderWriter": "4.0.11", + "System.Xml.XDocument": "4.0.11" + } + }, + "runtime.native.System/4.0.0": { + "dependencies": { + "Microsoft.NETCore.Platforms": "1.0.1", + "Microsoft.NETCore.Targets": "1.0.1" + }, + "compile": { + "lib/netstandard1.0/_._": {} + }, + "runtime": { + "lib/netstandard1.0/_._": {} + } + }, + "runtime.native.System.IO.Compression/4.1.0": { + "dependencies": { + "Microsoft.NETCore.Platforms": "1.0.1", + "Microsoft.NETCore.Targets": "1.0.1" + }, + "compile": { + "lib/netstandard1.0/_._": {} + }, + "runtime": { + "lib/netstandard1.0/_._": {} + } + }, + "runtime.native.System.Net.Http/4.0.1": { + "dependencies": { + "Microsoft.NETCore.Platforms": "1.0.1", + "Microsoft.NETCore.Targets": "1.0.1" + }, + "compile": { + "lib/netstandard1.0/_._": {} + }, + "runtime": { + "lib/netstandard1.0/_._": {} + } + }, + "runtime.native.System.Security.Cryptography/4.0.0": { + "dependencies": { + "Microsoft.NETCore.Platforms": "1.0.1", + "Microsoft.NETCore.Targets": "1.0.1" + }, + "compile": { + "lib/netstandard1.0/_._": {} + }, + "runtime": { + "lib/netstandard1.0/_._": {} + } + }, + "System.AppContext/4.1.0": { + "dependencies": { + "System.Runtime": "4.1.0" + }, + "compile": { + "ref/netstandard1.6/System.AppContext.dll": {} + }, + "runtime": { + "lib/netstandard1.6/System.AppContext.dll": {} + } + }, + "System.Buffers/4.0.0": { + "dependencies": { + "System.Diagnostics.Debug": "4.0.11", + "System.Diagnostics.Tracing": "4.1.0", + "System.Resources.ResourceManager": "4.0.1", + "System.Runtime": "4.1.0", + "System.Threading": "4.0.11" + }, + "compile": { + "lib/netstandard1.1/_._": {} + }, + "runtime": { + "lib/netstandard1.1/System.Buffers.dll": {} + } + }, + "System.Collections/4.0.11": { + "dependencies": { + "Microsoft.NETCore.Platforms": "1.0.1", + "Microsoft.NETCore.Targets": "1.0.1", + "System.Runtime": "4.1.0" + }, + "compile": { + "ref/netstandard1.3/System.Collections.dll": {} + } + }, + "System.Collections.Concurrent/4.0.12": { + "dependencies": { + "System.Collections": "4.0.11", + "System.Diagnostics.Debug": "4.0.11", + "System.Diagnostics.Tracing": "4.1.0", + "System.Globalization": "4.0.11", + "System.Reflection": "4.1.0", + "System.Resources.ResourceManager": "4.0.1", + "System.Runtime": "4.1.0", + "System.Runtime.Extensions": "4.1.0", + "System.Threading": "4.0.11", + "System.Threading.Tasks": "4.0.11" + }, + "compile": { + "ref/netstandard1.3/System.Collections.Concurrent.dll": {} + }, + "runtime": { + "lib/netstandard1.3/System.Collections.Concurrent.dll": {} + } + }, + "System.Console/4.0.0": { + "dependencies": { + "Microsoft.NETCore.Platforms": "1.0.1", + "Microsoft.NETCore.Targets": "1.0.1", + "System.IO": "4.1.0", + "System.Runtime": "4.1.0", + "System.Text.Encoding": "4.0.11" + }, + "compile": { + "ref/netstandard1.3/System.Console.dll": {} + } + }, + "System.Diagnostics.Debug/4.0.11": { + "dependencies": { + "Microsoft.NETCore.Platforms": "1.0.1", + "Microsoft.NETCore.Targets": "1.0.1", + "System.Runtime": "4.1.0" + }, + "compile": { + "ref/netstandard1.3/System.Diagnostics.Debug.dll": {} + } + }, + "System.Diagnostics.DiagnosticSource/4.0.0": { + "dependencies": { + "System.Collections": "4.0.11", + "System.Diagnostics.Tracing": "4.1.0", + "System.Reflection": "4.1.0", + "System.Runtime": "4.1.0", + "System.Threading": "4.0.11" + }, + "compile": { + "lib/netstandard1.3/_._": {} + }, + "runtime": { + "lib/netstandard1.3/System.Diagnostics.DiagnosticSource.dll": {} + } + }, + "System.Diagnostics.Tools/4.0.1": { + "dependencies": { + "Microsoft.NETCore.Platforms": "1.0.1", + "Microsoft.NETCore.Targets": "1.0.1", + "System.Runtime": "4.1.0" + }, + "compile": { + "ref/netstandard1.0/System.Diagnostics.Tools.dll": {} + } + }, + "System.Diagnostics.Tracing/4.1.0": { + "dependencies": { + "Microsoft.NETCore.Platforms": "1.0.1", + "Microsoft.NETCore.Targets": "1.0.1", + "System.Runtime": "4.1.0" + }, + "compile": { + "ref/netstandard1.5/System.Diagnostics.Tracing.dll": {} + } + }, + "System.Globalization/4.0.11": { + "dependencies": { + "Microsoft.NETCore.Platforms": "1.0.1", + "Microsoft.NETCore.Targets": "1.0.1", + "System.Runtime": "4.1.0" + }, + "compile": { + "ref/netstandard1.3/System.Globalization.dll": {} + } + }, + "System.Globalization.Calendars/4.0.1": { + "dependencies": { + "Microsoft.NETCore.Platforms": "1.0.1", + "Microsoft.NETCore.Targets": "1.0.1", + "System.Globalization": "4.0.11", + "System.Runtime": "4.1.0" + }, + "compile": { + "ref/netstandard1.3/System.Globalization.Calendars.dll": {} + } + }, + "System.Globalization.Extensions/4.0.1": { + "dependencies": { + "Microsoft.NETCore.Platforms": "1.0.1", + "System.Globalization": "4.0.11", + "System.Resources.ResourceManager": "4.0.1", + "System.Runtime": "4.1.0", + "System.Runtime.Extensions": "4.1.0", + "System.Runtime.InteropServices": "4.1.0" + }, + "compile": { + "ref/netstandard1.3/_._": {} + }, + "runtimeTargets": { + "runtimes/unix/lib/netstandard1.3/System.Globalization.Extensions.dll": { + "assetType": "runtime", + "rid": "unix" + }, + "runtimes/win/lib/netstandard1.3/System.Globalization.Extensions.dll": { + "assetType": "runtime", + "rid": "win" + } + } + }, + "System.IO/4.1.0": { + "dependencies": { + "Microsoft.NETCore.Platforms": "1.0.1", + "Microsoft.NETCore.Targets": "1.0.1", + "System.Runtime": "4.1.0", + "System.Text.Encoding": "4.0.11", + "System.Threading.Tasks": "4.0.11" + }, + "compile": { + "ref/netstandard1.5/System.IO.dll": {} + } + }, + "System.IO.Compression/4.1.0": { + "dependencies": { + "Microsoft.NETCore.Platforms": "1.0.1", + "System.Collections": "4.0.11", + "System.Diagnostics.Debug": "4.0.11", + "System.IO": "4.1.0", + "System.Resources.ResourceManager": "4.0.1", + "System.Runtime": "4.1.0", + "System.Runtime.Extensions": "4.1.0", + "System.Runtime.Handles": "4.0.1", + "System.Runtime.InteropServices": "4.1.0", + "System.Text.Encoding": "4.0.11", + "System.Threading": "4.0.11", + "System.Threading.Tasks": "4.0.11", + "runtime.native.System": "4.0.0", + "runtime.native.System.IO.Compression": "4.1.0" + }, + "compile": { + "ref/netstandard1.3/System.IO.Compression.dll": {} + }, + "runtimeTargets": { + "runtimes/unix/lib/netstandard1.3/System.IO.Compression.dll": { + "assetType": "runtime", + "rid": "unix" + }, + "runtimes/win/lib/netstandard1.3/System.IO.Compression.dll": { + "assetType": "runtime", + "rid": "win" + } + } + }, + "System.IO.Compression.ZipFile/4.0.1": { + "dependencies": { + "System.Buffers": "4.0.0", + "System.IO": "4.1.0", + "System.IO.Compression": "4.1.0", + "System.IO.FileSystem": "4.0.1", + "System.IO.FileSystem.Primitives": "4.0.1", + "System.Resources.ResourceManager": "4.0.1", + "System.Runtime": "4.1.0", + "System.Runtime.Extensions": "4.1.0", + "System.Text.Encoding": "4.0.11" + }, + "compile": { + "ref/netstandard1.3/System.IO.Compression.ZipFile.dll": {} + }, + "runtime": { + "lib/netstandard1.3/System.IO.Compression.ZipFile.dll": {} + } + }, + "System.IO.FileSystem/4.0.1": { + "dependencies": { + "Microsoft.NETCore.Platforms": "1.0.1", + "Microsoft.NETCore.Targets": "1.0.1", + "System.IO": "4.1.0", + "System.IO.FileSystem.Primitives": "4.0.1", + "System.Runtime": "4.1.0", + "System.Runtime.Handles": "4.0.1", + "System.Text.Encoding": "4.0.11", + "System.Threading.Tasks": "4.0.11" + }, + "compile": { + "ref/netstandard1.3/System.IO.FileSystem.dll": {} + } + }, + "System.IO.FileSystem.Primitives/4.0.1": { + "dependencies": { + "System.Runtime": "4.1.0" + }, + "compile": { + "ref/netstandard1.3/System.IO.FileSystem.Primitives.dll": {} + }, + "runtime": { + "lib/netstandard1.3/System.IO.FileSystem.Primitives.dll": {} + } + }, + "System.Linq/4.1.0": { + "dependencies": { + "System.Collections": "4.0.11", + "System.Diagnostics.Debug": "4.0.11", + "System.Resources.ResourceManager": "4.0.1", + "System.Runtime": "4.1.0", + "System.Runtime.Extensions": "4.1.0" + }, + "compile": { + "ref/netstandard1.6/System.Linq.dll": {} + }, + "runtime": { + "lib/netstandard1.6/System.Linq.dll": {} + } + }, + "System.Linq.Expressions/4.1.0": { + "dependencies": { + "System.Collections": "4.0.11", + "System.Diagnostics.Debug": "4.0.11", + "System.Globalization": "4.0.11", + "System.IO": "4.1.0", + "System.Linq": "4.1.0", + "System.ObjectModel": "4.0.12", + "System.Reflection": "4.1.0", + "System.Reflection.Emit": "4.0.1", + "System.Reflection.Emit.ILGeneration": "4.0.1", + "System.Reflection.Emit.Lightweight": "4.0.1", + "System.Reflection.Extensions": "4.0.1", + "System.Reflection.Primitives": "4.0.1", + "System.Reflection.TypeExtensions": "4.1.0", + "System.Resources.ResourceManager": "4.0.1", + "System.Runtime": "4.1.0", + "System.Runtime.Extensions": "4.1.0", + "System.Threading": "4.0.11" + }, + "compile": { + "ref/netstandard1.6/System.Linq.Expressions.dll": {} + }, + "runtime": { + "lib/netstandard1.6/System.Linq.Expressions.dll": {} + } + }, + "System.Net.Http/4.1.0": { + "dependencies": { + "Microsoft.NETCore.Platforms": "1.0.1", + "System.Collections": "4.0.11", + "System.Diagnostics.Debug": "4.0.11", + "System.Diagnostics.DiagnosticSource": "4.0.0", + "System.Diagnostics.Tracing": "4.1.0", + "System.Globalization": "4.0.11", + "System.Globalization.Extensions": "4.0.1", + "System.IO": "4.1.0", + "System.IO.FileSystem": "4.0.1", + "System.Net.Primitives": "4.0.11", + "System.Resources.ResourceManager": "4.0.1", + "System.Runtime": "4.1.0", + "System.Runtime.Extensions": "4.1.0", + "System.Runtime.Handles": "4.0.1", + "System.Runtime.InteropServices": "4.1.0", + "System.Security.Cryptography.Algorithms": "4.2.0", + "System.Security.Cryptography.Encoding": "4.0.0", + "System.Security.Cryptography.OpenSsl": "4.0.0", + "System.Security.Cryptography.Primitives": "4.0.0", + "System.Security.Cryptography.X509Certificates": "4.1.0", + "System.Text.Encoding": "4.0.11", + "System.Threading": "4.0.11", + "System.Threading.Tasks": "4.0.11", + "runtime.native.System": "4.0.0", + "runtime.native.System.Net.Http": "4.0.1", + "runtime.native.System.Security.Cryptography": "4.0.0" + }, + "compile": { + "ref/netstandard1.3/System.Net.Http.dll": {} + }, + "runtimeTargets": { + "runtimes/unix/lib/netstandard1.6/System.Net.Http.dll": { + "assetType": "runtime", + "rid": "unix" + }, + "runtimes/win/lib/netstandard1.3/System.Net.Http.dll": { + "assetType": "runtime", + "rid": "win" + } + } + }, + "System.Net.Primitives/4.0.11": { + "dependencies": { + "Microsoft.NETCore.Platforms": "1.0.1", + "Microsoft.NETCore.Targets": "1.0.1", + "System.Runtime": "4.1.0", + "System.Runtime.Handles": "4.0.1" + }, + "compile": { + "ref/netstandard1.3/System.Net.Primitives.dll": {} + } + }, + "System.Net.Sockets/4.1.0": { + "dependencies": { + "Microsoft.NETCore.Platforms": "1.0.1", + "Microsoft.NETCore.Targets": "1.0.1", + "System.IO": "4.1.0", + "System.Net.Primitives": "4.0.11", + "System.Runtime": "4.1.0", + "System.Threading.Tasks": "4.0.11" + }, + "compile": { + "ref/netstandard1.3/System.Net.Sockets.dll": {} + } + }, + "System.ObjectModel/4.0.12": { + "dependencies": { + "System.Collections": "4.0.11", + "System.Diagnostics.Debug": "4.0.11", + "System.Resources.ResourceManager": "4.0.1", + "System.Runtime": "4.1.0", + "System.Threading": "4.0.11" + }, + "compile": { + "ref/netstandard1.3/System.ObjectModel.dll": {} + }, + "runtime": { + "lib/netstandard1.3/System.ObjectModel.dll": {} + } + }, + "System.Reflection/4.1.0": { + "dependencies": { + "Microsoft.NETCore.Platforms": "1.0.1", + "Microsoft.NETCore.Targets": "1.0.1", + "System.IO": "4.1.0", + "System.Reflection.Primitives": "4.0.1", + "System.Runtime": "4.1.0" + }, + "compile": { + "ref/netstandard1.5/System.Reflection.dll": {} + } + }, + "System.Reflection.Emit/4.0.1": { + "dependencies": { + "System.IO": "4.1.0", + "System.Reflection": "4.1.0", + "System.Reflection.Emit.ILGeneration": "4.0.1", + "System.Reflection.Primitives": "4.0.1", + "System.Runtime": "4.1.0" + }, + "compile": { + "ref/netstandard1.1/_._": {} + }, + "runtime": { + "lib/netstandard1.3/System.Reflection.Emit.dll": {} + } + }, + "System.Reflection.Emit.ILGeneration/4.0.1": { + "dependencies": { + "System.Reflection": "4.1.0", + "System.Reflection.Primitives": "4.0.1", + "System.Runtime": "4.1.0" + }, + "compile": { + "ref/netstandard1.0/_._": {} + }, + "runtime": { + "lib/netstandard1.3/System.Reflection.Emit.ILGeneration.dll": {} + } + }, + "System.Reflection.Emit.Lightweight/4.0.1": { + "dependencies": { + "System.Reflection": "4.1.0", + "System.Reflection.Emit.ILGeneration": "4.0.1", + "System.Reflection.Primitives": "4.0.1", + "System.Runtime": "4.1.0" + }, + "compile": { + "ref/netstandard1.0/_._": {} + }, + "runtime": { + "lib/netstandard1.3/System.Reflection.Emit.Lightweight.dll": {} + } + }, + "System.Reflection.Extensions/4.0.1": { + "dependencies": { + "Microsoft.NETCore.Platforms": "1.0.1", + "Microsoft.NETCore.Targets": "1.0.1", + "System.Reflection": "4.1.0", + "System.Runtime": "4.1.0" + }, + "compile": { + "ref/netstandard1.0/System.Reflection.Extensions.dll": {} + } + }, + "System.Reflection.Primitives/4.0.1": { + "dependencies": { + "Microsoft.NETCore.Platforms": "1.0.1", + "Microsoft.NETCore.Targets": "1.0.1", + "System.Runtime": "4.1.0" + }, + "compile": { + "ref/netstandard1.0/System.Reflection.Primitives.dll": {} + } + }, + "System.Reflection.TypeExtensions/4.1.0": { + "dependencies": { + "System.Reflection": "4.1.0", + "System.Runtime": "4.1.0" + }, + "compile": { + "ref/netstandard1.5/_._": {} + }, + "runtime": { + "lib/netstandard1.5/System.Reflection.TypeExtensions.dll": {} + } + }, + "System.Resources.ResourceManager/4.0.1": { + "dependencies": { + "Microsoft.NETCore.Platforms": "1.0.1", + "Microsoft.NETCore.Targets": "1.0.1", + "System.Globalization": "4.0.11", + "System.Reflection": "4.1.0", + "System.Runtime": "4.1.0" + }, + "compile": { + "ref/netstandard1.0/System.Resources.ResourceManager.dll": {} + } + }, + "System.Runtime/4.1.0": { + "dependencies": { + "Microsoft.NETCore.Platforms": "1.0.1", + "Microsoft.NETCore.Targets": "1.0.1" + }, + "compile": { + "ref/netstandard1.5/System.Runtime.dll": {} + } + }, + "System.Runtime.Extensions/4.1.0": { + "dependencies": { + "Microsoft.NETCore.Platforms": "1.0.1", + "Microsoft.NETCore.Targets": "1.0.1", + "System.Runtime": "4.1.0" + }, + "compile": { + "ref/netstandard1.5/System.Runtime.Extensions.dll": {} + } + }, + "System.Runtime.Handles/4.0.1": { + "dependencies": { + "Microsoft.NETCore.Platforms": "1.0.1", + "Microsoft.NETCore.Targets": "1.0.1", + "System.Runtime": "4.1.0" + }, + "compile": { + "ref/netstandard1.3/System.Runtime.Handles.dll": {} + } + }, + "System.Runtime.InteropServices/4.1.0": { + "dependencies": { + "Microsoft.NETCore.Platforms": "1.0.1", + "Microsoft.NETCore.Targets": "1.0.1", + "System.Reflection": "4.1.0", + "System.Reflection.Primitives": "4.0.1", + "System.Runtime": "4.1.0", + "System.Runtime.Handles": "4.0.1" + }, + "compile": { + "ref/netstandard1.5/System.Runtime.InteropServices.dll": {} + } + }, + "System.Runtime.InteropServices.RuntimeInformation/4.0.0": { + "dependencies": { + "Microsoft.NETCore.Platforms": "1.0.1", + "System.Reflection": "4.1.0", + "System.Resources.ResourceManager": "4.0.1", + "System.Runtime": "4.1.0", + "System.Runtime.InteropServices": "4.1.0", + "System.Threading": "4.0.11", + "runtime.native.System": "4.0.0" + }, + "compile": { + "ref/netstandard1.1/System.Runtime.InteropServices.RuntimeInformation.dll": {} + }, + "runtimeTargets": { + "runtimes/unix/lib/netstandard1.1/System.Runtime.InteropServices.RuntimeInformation.dll": { + "assetType": "runtime", + "rid": "unix" + }, + "runtimes/win/lib/netstandard1.1/System.Runtime.InteropServices.RuntimeInformation.dll": { + "assetType": "runtime", + "rid": "win" + } + } + }, + "System.Runtime.Numerics/4.0.1": { + "dependencies": { + "System.Globalization": "4.0.11", + "System.Resources.ResourceManager": "4.0.1", + "System.Runtime": "4.1.0", + "System.Runtime.Extensions": "4.1.0" + }, + "compile": { + "ref/netstandard1.1/System.Runtime.Numerics.dll": {} + }, + "runtime": { + "lib/netstandard1.3/System.Runtime.Numerics.dll": {} + } + }, + "System.Security.Cryptography.Algorithms/4.2.0": { + "dependencies": { + "Microsoft.NETCore.Platforms": "1.0.1", + "System.Collections": "4.0.11", + "System.IO": "4.1.0", + "System.Resources.ResourceManager": "4.0.1", + "System.Runtime": "4.1.0", + "System.Runtime.Extensions": "4.1.0", + "System.Runtime.Handles": "4.0.1", + "System.Runtime.InteropServices": "4.1.0", + "System.Runtime.Numerics": "4.0.1", + "System.Security.Cryptography.Encoding": "4.0.0", + "System.Security.Cryptography.Primitives": "4.0.0", + "System.Text.Encoding": "4.0.11", + "runtime.native.System.Security.Cryptography": "4.0.0" + }, + "compile": { + "ref/netstandard1.6/System.Security.Cryptography.Algorithms.dll": {} + }, + "runtimeTargets": { + "runtimes/unix/lib/netstandard1.6/System.Security.Cryptography.Algorithms.dll": { + "assetType": "runtime", + "rid": "unix" + }, + "runtimes/win/lib/netstandard1.6/System.Security.Cryptography.Algorithms.dll": { + "assetType": "runtime", + "rid": "win" + } + } + }, + "System.Security.Cryptography.Cng/4.2.0": { + "dependencies": { + "Microsoft.NETCore.Platforms": "1.0.1", + "System.IO": "4.1.0", + "System.Resources.ResourceManager": "4.0.1", + "System.Runtime": "4.1.0", + "System.Runtime.Extensions": "4.1.0", + "System.Runtime.Handles": "4.0.1", + "System.Runtime.InteropServices": "4.1.0", + "System.Security.Cryptography.Algorithms": "4.2.0", + "System.Security.Cryptography.Encoding": "4.0.0", + "System.Security.Cryptography.Primitives": "4.0.0", + "System.Text.Encoding": "4.0.11" + }, + "compile": { + "ref/netstandard1.6/_._": {} + }, + "runtimeTargets": { + "runtimes/unix/lib/netstandard1.6/System.Security.Cryptography.Cng.dll": { + "assetType": "runtime", + "rid": "unix" + }, + "runtimes/win/lib/netstandard1.6/System.Security.Cryptography.Cng.dll": { + "assetType": "runtime", + "rid": "win" + } + } + }, + "System.Security.Cryptography.Csp/4.0.0": { + "dependencies": { + "Microsoft.NETCore.Platforms": "1.0.1", + "System.IO": "4.1.0", + "System.Reflection": "4.1.0", + "System.Resources.ResourceManager": "4.0.1", + "System.Runtime": "4.1.0", + "System.Runtime.Extensions": "4.1.0", + "System.Runtime.Handles": "4.0.1", + "System.Runtime.InteropServices": "4.1.0", + "System.Security.Cryptography.Algorithms": "4.2.0", + "System.Security.Cryptography.Encoding": "4.0.0", + "System.Security.Cryptography.Primitives": "4.0.0", + "System.Text.Encoding": "4.0.11", + "System.Threading": "4.0.11" + }, + "compile": { + "ref/netstandard1.3/_._": {} + }, + "runtimeTargets": { + "runtimes/unix/lib/netstandard1.3/System.Security.Cryptography.Csp.dll": { + "assetType": "runtime", + "rid": "unix" + }, + "runtimes/win/lib/netstandard1.3/System.Security.Cryptography.Csp.dll": { + "assetType": "runtime", + "rid": "win" + } + } + }, + "System.Security.Cryptography.Encoding/4.0.0": { + "dependencies": { + "Microsoft.NETCore.Platforms": "1.0.1", + "System.Collections": "4.0.11", + "System.Collections.Concurrent": "4.0.12", + "System.Linq": "4.1.0", + "System.Resources.ResourceManager": "4.0.1", + "System.Runtime": "4.1.0", + "System.Runtime.Extensions": "4.1.0", + "System.Runtime.Handles": "4.0.1", + "System.Runtime.InteropServices": "4.1.0", + "System.Security.Cryptography.Primitives": "4.0.0", + "System.Text.Encoding": "4.0.11", + "runtime.native.System.Security.Cryptography": "4.0.0" + }, + "compile": { + "ref/netstandard1.3/System.Security.Cryptography.Encoding.dll": {} + }, + "runtimeTargets": { + "runtimes/unix/lib/netstandard1.3/System.Security.Cryptography.Encoding.dll": { + "assetType": "runtime", + "rid": "unix" + }, + "runtimes/win/lib/netstandard1.3/System.Security.Cryptography.Encoding.dll": { + "assetType": "runtime", + "rid": "win" + } + } + }, + "System.Security.Cryptography.OpenSsl/4.0.0": { + "dependencies": { + "System.Collections": "4.0.11", + "System.IO": "4.1.0", + "System.Resources.ResourceManager": "4.0.1", + "System.Runtime": "4.1.0", + "System.Runtime.Extensions": "4.1.0", + "System.Runtime.Handles": "4.0.1", + "System.Runtime.InteropServices": "4.1.0", + "System.Runtime.Numerics": "4.0.1", + "System.Security.Cryptography.Algorithms": "4.2.0", + "System.Security.Cryptography.Encoding": "4.0.0", + "System.Security.Cryptography.Primitives": "4.0.0", + "System.Text.Encoding": "4.0.11", + "runtime.native.System.Security.Cryptography": "4.0.0" + }, + "compile": { + "ref/netstandard1.6/_._": {} + }, + "runtime": { + "lib/netstandard1.6/System.Security.Cryptography.OpenSsl.dll": {} + }, + "runtimeTargets": { + "runtimes/unix/lib/netstandard1.6/System.Security.Cryptography.OpenSsl.dll": { + "assetType": "runtime", + "rid": "unix" + } + } + }, + "System.Security.Cryptography.Primitives/4.0.0": { + "dependencies": { + "System.Diagnostics.Debug": "4.0.11", + "System.Globalization": "4.0.11", + "System.IO": "4.1.0", + "System.Resources.ResourceManager": "4.0.1", + "System.Runtime": "4.1.0", + "System.Threading": "4.0.11", + "System.Threading.Tasks": "4.0.11" + }, + "compile": { + "ref/netstandard1.3/System.Security.Cryptography.Primitives.dll": {} + }, + "runtime": { + "lib/netstandard1.3/System.Security.Cryptography.Primitives.dll": {} + } + }, + "System.Security.Cryptography.X509Certificates/4.1.0": { + "dependencies": { + "Microsoft.NETCore.Platforms": "1.0.1", + "System.Collections": "4.0.11", + "System.Diagnostics.Debug": "4.0.11", + "System.Globalization": "4.0.11", + "System.Globalization.Calendars": "4.0.1", + "System.IO": "4.1.0", + "System.IO.FileSystem": "4.0.1", + "System.IO.FileSystem.Primitives": "4.0.1", + "System.Resources.ResourceManager": "4.0.1", + "System.Runtime": "4.1.0", + "System.Runtime.Extensions": "4.1.0", + "System.Runtime.Handles": "4.0.1", + "System.Runtime.InteropServices": "4.1.0", + "System.Runtime.Numerics": "4.0.1", + "System.Security.Cryptography.Algorithms": "4.2.0", + "System.Security.Cryptography.Cng": "4.2.0", + "System.Security.Cryptography.Csp": "4.0.0", + "System.Security.Cryptography.Encoding": "4.0.0", + "System.Security.Cryptography.OpenSsl": "4.0.0", + "System.Security.Cryptography.Primitives": "4.0.0", + "System.Text.Encoding": "4.0.11", + "System.Threading": "4.0.11", + "runtime.native.System": "4.0.0", + "runtime.native.System.Net.Http": "4.0.1", + "runtime.native.System.Security.Cryptography": "4.0.0" + }, + "compile": { + "ref/netstandard1.4/System.Security.Cryptography.X509Certificates.dll": {} + }, + "runtimeTargets": { + "runtimes/unix/lib/netstandard1.6/System.Security.Cryptography.X509Certificates.dll": { + "assetType": "runtime", + "rid": "unix" + }, + "runtimes/win/lib/netstandard1.6/System.Security.Cryptography.X509Certificates.dll": { + "assetType": "runtime", + "rid": "win" + } + } + }, + "System.Text.Encoding/4.0.11": { + "dependencies": { + "Microsoft.NETCore.Platforms": "1.0.1", + "Microsoft.NETCore.Targets": "1.0.1", + "System.Runtime": "4.1.0" + }, + "compile": { + "ref/netstandard1.3/System.Text.Encoding.dll": {} + } + }, + "System.Text.Encoding.Extensions/4.0.11": { + "dependencies": { + "Microsoft.NETCore.Platforms": "1.0.1", + "Microsoft.NETCore.Targets": "1.0.1", + "System.Runtime": "4.1.0", + "System.Text.Encoding": "4.0.11" + }, + "compile": { + "ref/netstandard1.3/System.Text.Encoding.Extensions.dll": {} + } + }, + "System.Text.RegularExpressions/4.1.0": { + "dependencies": { + "System.Collections": "4.0.11", + "System.Globalization": "4.0.11", + "System.Resources.ResourceManager": "4.0.1", + "System.Runtime": "4.1.0", + "System.Runtime.Extensions": "4.1.0", + "System.Threading": "4.0.11" + }, + "compile": { + "ref/netstandard1.6/System.Text.RegularExpressions.dll": {} + }, + "runtime": { + "lib/netstandard1.6/System.Text.RegularExpressions.dll": {} + } + }, + "System.Threading/4.0.11": { + "dependencies": { + "System.Runtime": "4.1.0", + "System.Threading.Tasks": "4.0.11" + }, + "compile": { + "ref/netstandard1.3/System.Threading.dll": {} + }, + "runtime": { + "lib/netstandard1.3/System.Threading.dll": {} + } + }, + "System.Threading.Tasks/4.0.11": { + "dependencies": { + "Microsoft.NETCore.Platforms": "1.0.1", + "Microsoft.NETCore.Targets": "1.0.1", + "System.Runtime": "4.1.0" + }, + "compile": { + "ref/netstandard1.3/System.Threading.Tasks.dll": {} + } + }, + "System.Threading.Tasks.Extensions/4.0.0": { + "dependencies": { + "System.Collections": "4.0.11", + "System.Runtime": "4.1.0", + "System.Threading.Tasks": "4.0.11" + }, + "compile": { + "lib/netstandard1.0/_._": {} + }, + "runtime": { + "lib/netstandard1.0/System.Threading.Tasks.Extensions.dll": {} + } + }, + "System.Threading.Timer/4.0.1": { + "dependencies": { + "Microsoft.NETCore.Platforms": "1.0.1", + "Microsoft.NETCore.Targets": "1.0.1", + "System.Runtime": "4.1.0" + }, + "compile": { + "ref/netstandard1.2/System.Threading.Timer.dll": {} + } + }, + "System.Xml.ReaderWriter/4.0.11": { + "dependencies": { + "System.Collections": "4.0.11", + "System.Diagnostics.Debug": "4.0.11", + "System.Globalization": "4.0.11", + "System.IO": "4.1.0", + "System.IO.FileSystem": "4.0.1", + "System.IO.FileSystem.Primitives": "4.0.1", + "System.Resources.ResourceManager": "4.0.1", + "System.Runtime": "4.1.0", + "System.Runtime.Extensions": "4.1.0", + "System.Runtime.InteropServices": "4.1.0", + "System.Text.Encoding": "4.0.11", + "System.Text.Encoding.Extensions": "4.0.11", + "System.Text.RegularExpressions": "4.1.0", + "System.Threading.Tasks": "4.0.11", + "System.Threading.Tasks.Extensions": "4.0.0" + }, + "compile": { + "ref/netstandard1.3/System.Xml.ReaderWriter.dll": {} + }, + "runtime": { + "lib/netstandard1.3/System.Xml.ReaderWriter.dll": {} + } + }, + "System.Xml.XDocument/4.0.11": { + "dependencies": { + "System.Collections": "4.0.11", + "System.Diagnostics.Debug": "4.0.11", + "System.Diagnostics.Tools": "4.0.1", + "System.Globalization": "4.0.11", + "System.IO": "4.1.0", + "System.Reflection": "4.1.0", + "System.Resources.ResourceManager": "4.0.1", + "System.Runtime": "4.1.0", + "System.Runtime.Extensions": "4.1.0", + "System.Text.Encoding": "4.0.11", + "System.Threading": "4.0.11", + "System.Xml.ReaderWriter": "4.0.11" + }, + "compile": { + "ref/netstandard1.3/System.Xml.XDocument.dll": {} + }, + "runtime": { + "lib/netstandard1.3/System.Xml.XDocument.dll": {} + } + } + } + }, + "libraries": { + "Microsoft.NETCore.Platforms/1.0.1": { + "sha512": "2G6OjjJzwBfNOO8myRV/nFrbTw5iA+DEm0N+qUqhrOmaVtn4pC77h38I1jsXGw5VH55+dPfQsqHD0We9sCl9FQ==", + "type": "package", + "path": "Microsoft.NETCore.Platforms/1.0.1", + "files": [ + "Microsoft.NETCore.Platforms.1.0.1.nupkg.sha512", + "Microsoft.NETCore.Platforms.nuspec", + "ThirdPartyNotices.txt", + "dotnet_library_license.txt", + "lib/netstandard1.0/_._", + "runtime.json" + ] + }, + "Microsoft.NETCore.Targets/1.0.1": { + "sha512": "rkn+fKobF/cbWfnnfBOQHKVKIOpxMZBvlSHkqDWgBpwGDcLRduvs3D9OLGeV6GWGvVwNlVi2CBbTjuPmtHvyNw==", + "type": "package", + "path": "Microsoft.NETCore.Targets/1.0.1", + "files": [ + "Microsoft.NETCore.Targets.1.0.1.nupkg.sha512", + "Microsoft.NETCore.Targets.nuspec", + "ThirdPartyNotices.txt", + "dotnet_library_license.txt", + "lib/netstandard1.0/_._", + "runtime.json" + ] + }, + "Microsoft.Win32.Primitives/4.0.1": { + "sha512": "fQnBHO9DgcmkC9dYSJoBqo6sH1VJwJprUHh8F3hbcRlxiQiBUuTntdk8tUwV490OqC2kQUrinGwZyQHTieuXRA==", + "type": "package", + "path": "Microsoft.Win32.Primitives/4.0.1", + "files": [ + "Microsoft.Win32.Primitives.4.0.1.nupkg.sha512", + "Microsoft.Win32.Primitives.nuspec", + "ThirdPartyNotices.txt", + "dotnet_library_license.txt", + "lib/MonoAndroid10/_._", + "lib/MonoTouch10/_._", + "lib/net46/Microsoft.Win32.Primitives.dll", + "lib/xamarinios10/_._", + "lib/xamarinmac20/_._", + "lib/xamarintvos10/_._", + "lib/xamarinwatchos10/_._", + "ref/MonoAndroid10/_._", + "ref/MonoTouch10/_._", + "ref/net46/Microsoft.Win32.Primitives.dll", + "ref/netstandard1.3/Microsoft.Win32.Primitives.dll", + "ref/netstandard1.3/Microsoft.Win32.Primitives.xml", + "ref/netstandard1.3/de/Microsoft.Win32.Primitives.xml", + "ref/netstandard1.3/es/Microsoft.Win32.Primitives.xml", + "ref/netstandard1.3/fr/Microsoft.Win32.Primitives.xml", + "ref/netstandard1.3/it/Microsoft.Win32.Primitives.xml", + "ref/netstandard1.3/ja/Microsoft.Win32.Primitives.xml", + "ref/netstandard1.3/ko/Microsoft.Win32.Primitives.xml", + "ref/netstandard1.3/ru/Microsoft.Win32.Primitives.xml", + "ref/netstandard1.3/zh-hans/Microsoft.Win32.Primitives.xml", + "ref/netstandard1.3/zh-hant/Microsoft.Win32.Primitives.xml", + "ref/xamarinios10/_._", + "ref/xamarinmac20/_._", + "ref/xamarintvos10/_._", + "ref/xamarinwatchos10/_._" + ] + }, + "NETStandard.Library/1.6.0": { + "sha512": "ypsCvIdCZ4IoYASJHt6tF2fMo7N30NLgV1EbmC+snO490OMl9FvVxmumw14rhReWU3j3g7BYudG6YCrchwHJlA==", + "type": "package", + "path": "NETStandard.Library/1.6.0", + "files": [ + "NETStandard.Library.1.6.0.nupkg.sha512", + "NETStandard.Library.nuspec", + "ThirdPartyNotices.txt", + "dotnet_library_license.txt" + ] + }, + "runtime.native.System/4.0.0": { + "sha512": "QfS/nQI7k/BLgmLrw7qm7YBoULEvgWnPI+cYsbfCVFTW8Aj+i8JhccxcFMu1RWms0YZzF+UHguNBK4Qn89e2Sg==", + "type": "package", + "path": "runtime.native.System/4.0.0", + "files": [ + "ThirdPartyNotices.txt", + "dotnet_library_license.txt", + "lib/netstandard1.0/_._", + "runtime.native.System.4.0.0.nupkg.sha512", + "runtime.native.System.nuspec" + ] + }, + "runtime.native.System.IO.Compression/4.1.0": { + "sha512": "Ob7nvnJBox1aaB222zSVZSkf4WrebPG4qFscfK7vmD7P7NxoSxACQLtO7ytWpqXDn2wcd/+45+EAZ7xjaPip8A==", + "type": "package", + "path": "runtime.native.System.IO.Compression/4.1.0", + "files": [ + "ThirdPartyNotices.txt", + "dotnet_library_license.txt", + "lib/netstandard1.0/_._", + "runtime.native.System.IO.Compression.4.1.0.nupkg.sha512", + "runtime.native.System.IO.Compression.nuspec" + ] + }, + "runtime.native.System.Net.Http/4.0.1": { + "sha512": "Nh0UPZx2Vifh8r+J+H2jxifZUD3sBrmolgiFWJd2yiNrxO0xTa6bAw3YwRn1VOiSen/tUXMS31ttNItCZ6lKuA==", + "type": "package", + "path": "runtime.native.System.Net.Http/4.0.1", + "files": [ + "ThirdPartyNotices.txt", + "dotnet_library_license.txt", + "lib/netstandard1.0/_._", + "runtime.native.System.Net.Http.4.0.1.nupkg.sha512", + "runtime.native.System.Net.Http.nuspec" + ] + }, + "runtime.native.System.Security.Cryptography/4.0.0": { + "sha512": "2CQK0jmO6Eu7ZeMgD+LOFbNJSXHFVQbCJJkEyEwowh1SCgYnrn9W9RykMfpeeVGw7h4IBvYikzpGUlmZTUafJw==", + "type": "package", + "path": "runtime.native.System.Security.Cryptography/4.0.0", + "files": [ + "ThirdPartyNotices.txt", + "dotnet_library_license.txt", + "lib/netstandard1.0/_._", + "runtime.native.System.Security.Cryptography.4.0.0.nupkg.sha512", + "runtime.native.System.Security.Cryptography.nuspec" + ] + }, + "System.AppContext/4.1.0": { + "sha512": "3QjO4jNV7PdKkmQAVp9atA+usVnKRwI3Kx1nMwJ93T0LcQfx7pKAYk0nKz5wn1oP5iqlhZuy6RXOFdhr7rDwow==", + "type": "package", + "path": "System.AppContext/4.1.0", + "files": [ + "System.AppContext.4.1.0.nupkg.sha512", + "System.AppContext.nuspec", + "ThirdPartyNotices.txt", + "dotnet_library_license.txt", + "lib/MonoAndroid10/_._", + "lib/MonoTouch10/_._", + "lib/net46/System.AppContext.dll", + "lib/net463/System.AppContext.dll", + "lib/netcore50/System.AppContext.dll", + "lib/netstandard1.6/System.AppContext.dll", + "lib/xamarinios10/_._", + "lib/xamarinmac20/_._", + "lib/xamarintvos10/_._", + "lib/xamarinwatchos10/_._", + "ref/MonoAndroid10/_._", + "ref/MonoTouch10/_._", + "ref/net46/System.AppContext.dll", + "ref/net463/System.AppContext.dll", + "ref/netstandard/_._", + "ref/netstandard1.3/System.AppContext.dll", + "ref/netstandard1.3/System.AppContext.xml", + "ref/netstandard1.3/de/System.AppContext.xml", + "ref/netstandard1.3/es/System.AppContext.xml", + "ref/netstandard1.3/fr/System.AppContext.xml", + "ref/netstandard1.3/it/System.AppContext.xml", + "ref/netstandard1.3/ja/System.AppContext.xml", + "ref/netstandard1.3/ko/System.AppContext.xml", + "ref/netstandard1.3/ru/System.AppContext.xml", + "ref/netstandard1.3/zh-hans/System.AppContext.xml", + "ref/netstandard1.3/zh-hant/System.AppContext.xml", + "ref/netstandard1.6/System.AppContext.dll", + "ref/netstandard1.6/System.AppContext.xml", + "ref/netstandard1.6/de/System.AppContext.xml", + "ref/netstandard1.6/es/System.AppContext.xml", + "ref/netstandard1.6/fr/System.AppContext.xml", + "ref/netstandard1.6/it/System.AppContext.xml", + "ref/netstandard1.6/ja/System.AppContext.xml", + "ref/netstandard1.6/ko/System.AppContext.xml", + "ref/netstandard1.6/ru/System.AppContext.xml", + "ref/netstandard1.6/zh-hans/System.AppContext.xml", + "ref/netstandard1.6/zh-hant/System.AppContext.xml", + "ref/xamarinios10/_._", + "ref/xamarinmac20/_._", + "ref/xamarintvos10/_._", + "ref/xamarinwatchos10/_._", + "runtimes/aot/lib/netcore50/System.AppContext.dll" + ] + }, + "System.Buffers/4.0.0": { + "sha512": "msXumHfjjURSkvxUjYuq4N2ghHoRi2VpXcKMA7gK6ujQfU3vGpl+B6ld0ATRg+FZFpRyA6PgEPA+VlIkTeNf2w==", + "type": "package", + "path": "System.Buffers/4.0.0", + "files": [ + "System.Buffers.4.0.0.nupkg.sha512", + "System.Buffers.nuspec", + "ThirdPartyNotices.txt", + "dotnet_library_license.txt", + "lib/netstandard1.1/.xml", + "lib/netstandard1.1/System.Buffers.dll" + ] + }, + "System.Collections/4.0.11": { + "sha512": "YUJGz6eFKqS0V//mLt25vFGrrCvOnsXjlvFQs+KimpwNxug9x0Pzy4PlFMU3Q2IzqAa9G2L4LsK3+9vCBK7oTg==", + "type": "package", + "path": "System.Collections/4.0.11", + "files": [ + "System.Collections.4.0.11.nupkg.sha512", + "System.Collections.nuspec", + "ThirdPartyNotices.txt", + "dotnet_library_license.txt", + "lib/MonoAndroid10/_._", + "lib/MonoTouch10/_._", + "lib/net45/_._", + "lib/portable-net45+win8+wp8+wpa81/_._", + "lib/win8/_._", + "lib/wp80/_._", + "lib/wpa81/_._", + "lib/xamarinios10/_._", + "lib/xamarinmac20/_._", + "lib/xamarintvos10/_._", + "lib/xamarinwatchos10/_._", + "ref/MonoAndroid10/_._", + "ref/MonoTouch10/_._", + "ref/net45/_._", + "ref/netcore50/System.Collections.dll", + "ref/netcore50/System.Collections.xml", + "ref/netcore50/de/System.Collections.xml", + "ref/netcore50/es/System.Collections.xml", + "ref/netcore50/fr/System.Collections.xml", + "ref/netcore50/it/System.Collections.xml", + "ref/netcore50/ja/System.Collections.xml", + "ref/netcore50/ko/System.Collections.xml", + "ref/netcore50/ru/System.Collections.xml", + "ref/netcore50/zh-hans/System.Collections.xml", + "ref/netcore50/zh-hant/System.Collections.xml", + "ref/netstandard1.0/System.Collections.dll", + "ref/netstandard1.0/System.Collections.xml", + "ref/netstandard1.0/de/System.Collections.xml", + "ref/netstandard1.0/es/System.Collections.xml", + "ref/netstandard1.0/fr/System.Collections.xml", + "ref/netstandard1.0/it/System.Collections.xml", + "ref/netstandard1.0/ja/System.Collections.xml", + "ref/netstandard1.0/ko/System.Collections.xml", + "ref/netstandard1.0/ru/System.Collections.xml", + "ref/netstandard1.0/zh-hans/System.Collections.xml", + "ref/netstandard1.0/zh-hant/System.Collections.xml", + "ref/netstandard1.3/System.Collections.dll", + "ref/netstandard1.3/System.Collections.xml", + "ref/netstandard1.3/de/System.Collections.xml", + "ref/netstandard1.3/es/System.Collections.xml", + "ref/netstandard1.3/fr/System.Collections.xml", + "ref/netstandard1.3/it/System.Collections.xml", + "ref/netstandard1.3/ja/System.Collections.xml", + "ref/netstandard1.3/ko/System.Collections.xml", + "ref/netstandard1.3/ru/System.Collections.xml", + "ref/netstandard1.3/zh-hans/System.Collections.xml", + "ref/netstandard1.3/zh-hant/System.Collections.xml", + "ref/portable-net45+win8+wp8+wpa81/_._", + "ref/win8/_._", + "ref/wp80/_._", + "ref/wpa81/_._", + "ref/xamarinios10/_._", + "ref/xamarinmac20/_._", + "ref/xamarintvos10/_._", + "ref/xamarinwatchos10/_._" + ] + }, + "System.Collections.Concurrent/4.0.12": { + "sha512": "2gBcbb3drMLgxlI0fBfxMA31ec6AEyYCHygGse4vxceJan8mRIWeKJ24BFzN7+bi/NFTgdIgufzb94LWO5EERQ==", + "type": "package", + "path": "System.Collections.Concurrent/4.0.12", + "files": [ + "System.Collections.Concurrent.4.0.12.nupkg.sha512", + "System.Collections.Concurrent.nuspec", + "ThirdPartyNotices.txt", + "dotnet_library_license.txt", + "lib/MonoAndroid10/_._", + "lib/MonoTouch10/_._", + "lib/net45/_._", + "lib/netcore50/System.Collections.Concurrent.dll", + "lib/netstandard1.3/System.Collections.Concurrent.dll", + "lib/portable-net45+win8+wpa81/_._", + "lib/win8/_._", + "lib/wpa81/_._", + "lib/xamarinios10/_._", + "lib/xamarinmac20/_._", + "lib/xamarintvos10/_._", + "lib/xamarinwatchos10/_._", + "ref/MonoAndroid10/_._", + "ref/MonoTouch10/_._", + "ref/net45/_._", + "ref/netcore50/System.Collections.Concurrent.dll", + "ref/netcore50/System.Collections.Concurrent.xml", + "ref/netcore50/de/System.Collections.Concurrent.xml", + "ref/netcore50/es/System.Collections.Concurrent.xml", + "ref/netcore50/fr/System.Collections.Concurrent.xml", + "ref/netcore50/it/System.Collections.Concurrent.xml", + "ref/netcore50/ja/System.Collections.Concurrent.xml", + "ref/netcore50/ko/System.Collections.Concurrent.xml", + "ref/netcore50/ru/System.Collections.Concurrent.xml", + "ref/netcore50/zh-hans/System.Collections.Concurrent.xml", + "ref/netcore50/zh-hant/System.Collections.Concurrent.xml", + "ref/netstandard1.1/System.Collections.Concurrent.dll", + "ref/netstandard1.1/System.Collections.Concurrent.xml", + "ref/netstandard1.1/de/System.Collections.Concurrent.xml", + "ref/netstandard1.1/es/System.Collections.Concurrent.xml", + "ref/netstandard1.1/fr/System.Collections.Concurrent.xml", + "ref/netstandard1.1/it/System.Collections.Concurrent.xml", + "ref/netstandard1.1/ja/System.Collections.Concurrent.xml", + "ref/netstandard1.1/ko/System.Collections.Concurrent.xml", + "ref/netstandard1.1/ru/System.Collections.Concurrent.xml", + "ref/netstandard1.1/zh-hans/System.Collections.Concurrent.xml", + "ref/netstandard1.1/zh-hant/System.Collections.Concurrent.xml", + "ref/netstandard1.3/System.Collections.Concurrent.dll", + "ref/netstandard1.3/System.Collections.Concurrent.xml", + "ref/netstandard1.3/de/System.Collections.Concurrent.xml", + "ref/netstandard1.3/es/System.Collections.Concurrent.xml", + "ref/netstandard1.3/fr/System.Collections.Concurrent.xml", + "ref/netstandard1.3/it/System.Collections.Concurrent.xml", + "ref/netstandard1.3/ja/System.Collections.Concurrent.xml", + "ref/netstandard1.3/ko/System.Collections.Concurrent.xml", + "ref/netstandard1.3/ru/System.Collections.Concurrent.xml", + "ref/netstandard1.3/zh-hans/System.Collections.Concurrent.xml", + "ref/netstandard1.3/zh-hant/System.Collections.Concurrent.xml", + "ref/portable-net45+win8+wpa81/_._", + "ref/win8/_._", + "ref/wpa81/_._", + "ref/xamarinios10/_._", + "ref/xamarinmac20/_._", + "ref/xamarintvos10/_._", + "ref/xamarinwatchos10/_._" + ] + }, + "System.Console/4.0.0": { + "sha512": "qSKUSOIiYA/a0g5XXdxFcUFmv1hNICBD7QZ0QhGYVipPIhvpiydY8VZqr1thmCXvmn8aipMg64zuanB4eotK9A==", + "type": "package", + "path": "System.Console/4.0.0", + "files": [ + "System.Console.4.0.0.nupkg.sha512", + "System.Console.nuspec", + "ThirdPartyNotices.txt", + "dotnet_library_license.txt", + "lib/MonoAndroid10/_._", + "lib/MonoTouch10/_._", + "lib/net46/System.Console.dll", + "lib/xamarinios10/_._", + "lib/xamarinmac20/_._", + "lib/xamarintvos10/_._", + "lib/xamarinwatchos10/_._", + "ref/MonoAndroid10/_._", + "ref/MonoTouch10/_._", + "ref/net46/System.Console.dll", + "ref/netstandard1.3/System.Console.dll", + "ref/netstandard1.3/System.Console.xml", + "ref/netstandard1.3/de/System.Console.xml", + "ref/netstandard1.3/es/System.Console.xml", + "ref/netstandard1.3/fr/System.Console.xml", + "ref/netstandard1.3/it/System.Console.xml", + "ref/netstandard1.3/ja/System.Console.xml", + "ref/netstandard1.3/ko/System.Console.xml", + "ref/netstandard1.3/ru/System.Console.xml", + "ref/netstandard1.3/zh-hans/System.Console.xml", + "ref/netstandard1.3/zh-hant/System.Console.xml", + "ref/xamarinios10/_._", + "ref/xamarinmac20/_._", + "ref/xamarintvos10/_._", + "ref/xamarinwatchos10/_._" + ] + }, + "System.Diagnostics.Debug/4.0.11": { + "sha512": "w5U95fVKHY4G8ASs/K5iK3J5LY+/dLFd4vKejsnI/ZhBsWS9hQakfx3Zr7lRWKg4tAw9r4iktyvsTagWkqYCiw==", + "type": "package", + "path": "System.Diagnostics.Debug/4.0.11", + "files": [ + "System.Diagnostics.Debug.4.0.11.nupkg.sha512", + "System.Diagnostics.Debug.nuspec", + "ThirdPartyNotices.txt", + "dotnet_library_license.txt", + "lib/MonoAndroid10/_._", + "lib/MonoTouch10/_._", + "lib/net45/_._", + "lib/portable-net45+win8+wp8+wpa81/_._", + "lib/win8/_._", + "lib/wp80/_._", + "lib/wpa81/_._", + "lib/xamarinios10/_._", + "lib/xamarinmac20/_._", + "lib/xamarintvos10/_._", + "lib/xamarinwatchos10/_._", + "ref/MonoAndroid10/_._", + "ref/MonoTouch10/_._", + "ref/net45/_._", + "ref/netcore50/System.Diagnostics.Debug.dll", + "ref/netcore50/System.Diagnostics.Debug.xml", + "ref/netcore50/de/System.Diagnostics.Debug.xml", + "ref/netcore50/es/System.Diagnostics.Debug.xml", + "ref/netcore50/fr/System.Diagnostics.Debug.xml", + "ref/netcore50/it/System.Diagnostics.Debug.xml", + "ref/netcore50/ja/System.Diagnostics.Debug.xml", + "ref/netcore50/ko/System.Diagnostics.Debug.xml", + "ref/netcore50/ru/System.Diagnostics.Debug.xml", + "ref/netcore50/zh-hans/System.Diagnostics.Debug.xml", + "ref/netcore50/zh-hant/System.Diagnostics.Debug.xml", + "ref/netstandard1.0/System.Diagnostics.Debug.dll", + "ref/netstandard1.0/System.Diagnostics.Debug.xml", + "ref/netstandard1.0/de/System.Diagnostics.Debug.xml", + "ref/netstandard1.0/es/System.Diagnostics.Debug.xml", + "ref/netstandard1.0/fr/System.Diagnostics.Debug.xml", + "ref/netstandard1.0/it/System.Diagnostics.Debug.xml", + "ref/netstandard1.0/ja/System.Diagnostics.Debug.xml", + "ref/netstandard1.0/ko/System.Diagnostics.Debug.xml", + "ref/netstandard1.0/ru/System.Diagnostics.Debug.xml", + "ref/netstandard1.0/zh-hans/System.Diagnostics.Debug.xml", + "ref/netstandard1.0/zh-hant/System.Diagnostics.Debug.xml", + "ref/netstandard1.3/System.Diagnostics.Debug.dll", + "ref/netstandard1.3/System.Diagnostics.Debug.xml", + "ref/netstandard1.3/de/System.Diagnostics.Debug.xml", + "ref/netstandard1.3/es/System.Diagnostics.Debug.xml", + "ref/netstandard1.3/fr/System.Diagnostics.Debug.xml", + "ref/netstandard1.3/it/System.Diagnostics.Debug.xml", + "ref/netstandard1.3/ja/System.Diagnostics.Debug.xml", + "ref/netstandard1.3/ko/System.Diagnostics.Debug.xml", + "ref/netstandard1.3/ru/System.Diagnostics.Debug.xml", + "ref/netstandard1.3/zh-hans/System.Diagnostics.Debug.xml", + "ref/netstandard1.3/zh-hant/System.Diagnostics.Debug.xml", + "ref/portable-net45+win8+wp8+wpa81/_._", + "ref/win8/_._", + "ref/wp80/_._", + "ref/wpa81/_._", + "ref/xamarinios10/_._", + "ref/xamarinmac20/_._", + "ref/xamarintvos10/_._", + "ref/xamarinwatchos10/_._" + ] + }, + "System.Diagnostics.DiagnosticSource/4.0.0": { + "sha512": "YKglnq4BMTJxfcr6nuT08g+yJ0UxdePIHxosiLuljuHIUR6t4KhFsyaHOaOc1Ofqp0PUvJ0EmcgiEz6T7vEx3w==", + "type": "package", + "path": "System.Diagnostics.DiagnosticSource/4.0.0", + "files": [ + "System.Diagnostics.DiagnosticSource.4.0.0.nupkg.sha512", + "System.Diagnostics.DiagnosticSource.nuspec", + "ThirdPartyNotices.txt", + "dotnet_library_license.txt", + "lib/net46/System.Diagnostics.DiagnosticSource.dll", + "lib/net46/System.Diagnostics.DiagnosticSource.xml", + "lib/netstandard1.1/System.Diagnostics.DiagnosticSource.dll", + "lib/netstandard1.1/System.Diagnostics.DiagnosticSource.xml", + "lib/netstandard1.3/System.Diagnostics.DiagnosticSource.dll", + "lib/netstandard1.3/System.Diagnostics.DiagnosticSource.xml", + "lib/portable-net45+win8+wpa81/System.Diagnostics.DiagnosticSource.dll", + "lib/portable-net45+win8+wpa81/System.Diagnostics.DiagnosticSource.xml" + ] + }, + "System.Diagnostics.Tools/4.0.1": { + "sha512": "xBfJ8pnd4C17dWaC9FM6aShzbJcRNMChUMD42I6772KGGrqaFdumwhn9OdM68erj1ueNo3xdQ1EwiFjK5k8p0g==", + "type": "package", + "path": "System.Diagnostics.Tools/4.0.1", + "files": [ + "System.Diagnostics.Tools.4.0.1.nupkg.sha512", + "System.Diagnostics.Tools.nuspec", + "ThirdPartyNotices.txt", + "dotnet_library_license.txt", + "lib/MonoAndroid10/_._", + "lib/MonoTouch10/_._", + "lib/net45/_._", + "lib/portable-net45+win8+wp8+wpa81/_._", + "lib/win8/_._", + "lib/wp80/_._", + "lib/wpa81/_._", + "lib/xamarinios10/_._", + "lib/xamarinmac20/_._", + "lib/xamarintvos10/_._", + "lib/xamarinwatchos10/_._", + "ref/MonoAndroid10/_._", + "ref/MonoTouch10/_._", + "ref/net45/_._", + "ref/netcore50/System.Diagnostics.Tools.dll", + "ref/netcore50/System.Diagnostics.Tools.xml", + "ref/netcore50/de/System.Diagnostics.Tools.xml", + "ref/netcore50/es/System.Diagnostics.Tools.xml", + "ref/netcore50/fr/System.Diagnostics.Tools.xml", + "ref/netcore50/it/System.Diagnostics.Tools.xml", + "ref/netcore50/ja/System.Diagnostics.Tools.xml", + "ref/netcore50/ko/System.Diagnostics.Tools.xml", + "ref/netcore50/ru/System.Diagnostics.Tools.xml", + "ref/netcore50/zh-hans/System.Diagnostics.Tools.xml", + "ref/netcore50/zh-hant/System.Diagnostics.Tools.xml", + "ref/netstandard1.0/System.Diagnostics.Tools.dll", + "ref/netstandard1.0/System.Diagnostics.Tools.xml", + "ref/netstandard1.0/de/System.Diagnostics.Tools.xml", + "ref/netstandard1.0/es/System.Diagnostics.Tools.xml", + "ref/netstandard1.0/fr/System.Diagnostics.Tools.xml", + "ref/netstandard1.0/it/System.Diagnostics.Tools.xml", + "ref/netstandard1.0/ja/System.Diagnostics.Tools.xml", + "ref/netstandard1.0/ko/System.Diagnostics.Tools.xml", + "ref/netstandard1.0/ru/System.Diagnostics.Tools.xml", + "ref/netstandard1.0/zh-hans/System.Diagnostics.Tools.xml", + "ref/netstandard1.0/zh-hant/System.Diagnostics.Tools.xml", + "ref/portable-net45+win8+wp8+wpa81/_._", + "ref/win8/_._", + "ref/wp80/_._", + "ref/wpa81/_._", + "ref/xamarinios10/_._", + "ref/xamarinmac20/_._", + "ref/xamarintvos10/_._", + "ref/xamarinwatchos10/_._" + ] + }, + "System.Diagnostics.Tracing/4.1.0": { + "sha512": "vDN1PoMZCkkdNjvZLql592oYJZgS7URcJzJ7bxeBgGtx5UtR5leNm49VmfHGqIffX4FKacHbI3H6UyNSHQknBg==", + "type": "package", + "path": "System.Diagnostics.Tracing/4.1.0", + "files": [ + "System.Diagnostics.Tracing.4.1.0.nupkg.sha512", + "System.Diagnostics.Tracing.nuspec", + "ThirdPartyNotices.txt", + "dotnet_library_license.txt", + "lib/MonoAndroid10/_._", + "lib/MonoTouch10/_._", + "lib/net45/_._", + "lib/net462/System.Diagnostics.Tracing.dll", + "lib/portable-net45+win8+wpa81/_._", + "lib/win8/_._", + "lib/wpa81/_._", + "lib/xamarinios10/_._", + "lib/xamarinmac20/_._", + "lib/xamarintvos10/_._", + "lib/xamarinwatchos10/_._", + "ref/MonoAndroid10/_._", + "ref/MonoTouch10/_._", + "ref/net45/_._", + "ref/net462/System.Diagnostics.Tracing.dll", + "ref/netcore50/System.Diagnostics.Tracing.dll", + "ref/netcore50/System.Diagnostics.Tracing.xml", + "ref/netcore50/de/System.Diagnostics.Tracing.xml", + "ref/netcore50/es/System.Diagnostics.Tracing.xml", + "ref/netcore50/fr/System.Diagnostics.Tracing.xml", + "ref/netcore50/it/System.Diagnostics.Tracing.xml", + "ref/netcore50/ja/System.Diagnostics.Tracing.xml", + "ref/netcore50/ko/System.Diagnostics.Tracing.xml", + "ref/netcore50/ru/System.Diagnostics.Tracing.xml", + "ref/netcore50/zh-hans/System.Diagnostics.Tracing.xml", + "ref/netcore50/zh-hant/System.Diagnostics.Tracing.xml", + "ref/netstandard1.1/System.Diagnostics.Tracing.dll", + "ref/netstandard1.1/System.Diagnostics.Tracing.xml", + "ref/netstandard1.1/de/System.Diagnostics.Tracing.xml", + "ref/netstandard1.1/es/System.Diagnostics.Tracing.xml", + "ref/netstandard1.1/fr/System.Diagnostics.Tracing.xml", + "ref/netstandard1.1/it/System.Diagnostics.Tracing.xml", + "ref/netstandard1.1/ja/System.Diagnostics.Tracing.xml", + "ref/netstandard1.1/ko/System.Diagnostics.Tracing.xml", + "ref/netstandard1.1/ru/System.Diagnostics.Tracing.xml", + "ref/netstandard1.1/zh-hans/System.Diagnostics.Tracing.xml", + "ref/netstandard1.1/zh-hant/System.Diagnostics.Tracing.xml", + "ref/netstandard1.2/System.Diagnostics.Tracing.dll", + "ref/netstandard1.2/System.Diagnostics.Tracing.xml", + "ref/netstandard1.2/de/System.Diagnostics.Tracing.xml", + "ref/netstandard1.2/es/System.Diagnostics.Tracing.xml", + "ref/netstandard1.2/fr/System.Diagnostics.Tracing.xml", + "ref/netstandard1.2/it/System.Diagnostics.Tracing.xml", + "ref/netstandard1.2/ja/System.Diagnostics.Tracing.xml", + "ref/netstandard1.2/ko/System.Diagnostics.Tracing.xml", + "ref/netstandard1.2/ru/System.Diagnostics.Tracing.xml", + "ref/netstandard1.2/zh-hans/System.Diagnostics.Tracing.xml", + "ref/netstandard1.2/zh-hant/System.Diagnostics.Tracing.xml", + "ref/netstandard1.3/System.Diagnostics.Tracing.dll", + "ref/netstandard1.3/System.Diagnostics.Tracing.xml", + "ref/netstandard1.3/de/System.Diagnostics.Tracing.xml", + "ref/netstandard1.3/es/System.Diagnostics.Tracing.xml", + "ref/netstandard1.3/fr/System.Diagnostics.Tracing.xml", + "ref/netstandard1.3/it/System.Diagnostics.Tracing.xml", + "ref/netstandard1.3/ja/System.Diagnostics.Tracing.xml", + "ref/netstandard1.3/ko/System.Diagnostics.Tracing.xml", + "ref/netstandard1.3/ru/System.Diagnostics.Tracing.xml", + "ref/netstandard1.3/zh-hans/System.Diagnostics.Tracing.xml", + "ref/netstandard1.3/zh-hant/System.Diagnostics.Tracing.xml", + "ref/netstandard1.5/System.Diagnostics.Tracing.dll", + "ref/netstandard1.5/System.Diagnostics.Tracing.xml", + "ref/netstandard1.5/de/System.Diagnostics.Tracing.xml", + "ref/netstandard1.5/es/System.Diagnostics.Tracing.xml", + "ref/netstandard1.5/fr/System.Diagnostics.Tracing.xml", + "ref/netstandard1.5/it/System.Diagnostics.Tracing.xml", + "ref/netstandard1.5/ja/System.Diagnostics.Tracing.xml", + "ref/netstandard1.5/ko/System.Diagnostics.Tracing.xml", + "ref/netstandard1.5/ru/System.Diagnostics.Tracing.xml", + "ref/netstandard1.5/zh-hans/System.Diagnostics.Tracing.xml", + "ref/netstandard1.5/zh-hant/System.Diagnostics.Tracing.xml", + "ref/portable-net45+win8+wpa81/_._", + "ref/win8/_._", + "ref/wpa81/_._", + "ref/xamarinios10/_._", + "ref/xamarinmac20/_._", + "ref/xamarintvos10/_._", + "ref/xamarinwatchos10/_._" + ] + }, + "System.Globalization/4.0.11": { + "sha512": "B95h0YLEL2oSnwF/XjqSWKnwKOy/01VWkNlsCeMTFJLLabflpGV26nK164eRs5GiaRSBGpOxQ3pKoSnnyZN5pg==", + "type": "package", + "path": "System.Globalization/4.0.11", + "files": [ + "System.Globalization.4.0.11.nupkg.sha512", + "System.Globalization.nuspec", + "ThirdPartyNotices.txt", + "dotnet_library_license.txt", + "lib/MonoAndroid10/_._", + "lib/MonoTouch10/_._", + "lib/net45/_._", + "lib/portable-net45+win8+wp8+wpa81/_._", + "lib/win8/_._", + "lib/wp80/_._", + "lib/wpa81/_._", + "lib/xamarinios10/_._", + "lib/xamarinmac20/_._", + "lib/xamarintvos10/_._", + "lib/xamarinwatchos10/_._", + "ref/MonoAndroid10/_._", + "ref/MonoTouch10/_._", + "ref/net45/_._", + "ref/netcore50/System.Globalization.dll", + "ref/netcore50/System.Globalization.xml", + "ref/netcore50/de/System.Globalization.xml", + "ref/netcore50/es/System.Globalization.xml", + "ref/netcore50/fr/System.Globalization.xml", + "ref/netcore50/it/System.Globalization.xml", + "ref/netcore50/ja/System.Globalization.xml", + "ref/netcore50/ko/System.Globalization.xml", + "ref/netcore50/ru/System.Globalization.xml", + "ref/netcore50/zh-hans/System.Globalization.xml", + "ref/netcore50/zh-hant/System.Globalization.xml", + "ref/netstandard1.0/System.Globalization.dll", + "ref/netstandard1.0/System.Globalization.xml", + "ref/netstandard1.0/de/System.Globalization.xml", + "ref/netstandard1.0/es/System.Globalization.xml", + "ref/netstandard1.0/fr/System.Globalization.xml", + "ref/netstandard1.0/it/System.Globalization.xml", + "ref/netstandard1.0/ja/System.Globalization.xml", + "ref/netstandard1.0/ko/System.Globalization.xml", + "ref/netstandard1.0/ru/System.Globalization.xml", + "ref/netstandard1.0/zh-hans/System.Globalization.xml", + "ref/netstandard1.0/zh-hant/System.Globalization.xml", + "ref/netstandard1.3/System.Globalization.dll", + "ref/netstandard1.3/System.Globalization.xml", + "ref/netstandard1.3/de/System.Globalization.xml", + "ref/netstandard1.3/es/System.Globalization.xml", + "ref/netstandard1.3/fr/System.Globalization.xml", + "ref/netstandard1.3/it/System.Globalization.xml", + "ref/netstandard1.3/ja/System.Globalization.xml", + "ref/netstandard1.3/ko/System.Globalization.xml", + "ref/netstandard1.3/ru/System.Globalization.xml", + "ref/netstandard1.3/zh-hans/System.Globalization.xml", + "ref/netstandard1.3/zh-hant/System.Globalization.xml", + "ref/portable-net45+win8+wp8+wpa81/_._", + "ref/win8/_._", + "ref/wp80/_._", + "ref/wpa81/_._", + "ref/xamarinios10/_._", + "ref/xamarinmac20/_._", + "ref/xamarintvos10/_._", + "ref/xamarinwatchos10/_._" + ] + }, + "System.Globalization.Calendars/4.0.1": { + "sha512": "L1c6IqeQ88vuzC1P81JeHmHA8mxq8a18NUBNXnIY/BVb+TCyAaGIFbhpZt60h9FJNmisymoQkHEFSE9Vslja1Q==", + "type": "package", + "path": "System.Globalization.Calendars/4.0.1", + "files": [ + "System.Globalization.Calendars.4.0.1.nupkg.sha512", + "System.Globalization.Calendars.nuspec", + "ThirdPartyNotices.txt", + "dotnet_library_license.txt", + "lib/MonoAndroid10/_._", + "lib/MonoTouch10/_._", + "lib/net46/System.Globalization.Calendars.dll", + "lib/xamarinios10/_._", + "lib/xamarinmac20/_._", + "lib/xamarintvos10/_._", + "lib/xamarinwatchos10/_._", + "ref/MonoAndroid10/_._", + "ref/MonoTouch10/_._", + "ref/net46/System.Globalization.Calendars.dll", + "ref/netstandard1.3/System.Globalization.Calendars.dll", + "ref/netstandard1.3/System.Globalization.Calendars.xml", + "ref/netstandard1.3/de/System.Globalization.Calendars.xml", + "ref/netstandard1.3/es/System.Globalization.Calendars.xml", + "ref/netstandard1.3/fr/System.Globalization.Calendars.xml", + "ref/netstandard1.3/it/System.Globalization.Calendars.xml", + "ref/netstandard1.3/ja/System.Globalization.Calendars.xml", + "ref/netstandard1.3/ko/System.Globalization.Calendars.xml", + "ref/netstandard1.3/ru/System.Globalization.Calendars.xml", + "ref/netstandard1.3/zh-hans/System.Globalization.Calendars.xml", + "ref/netstandard1.3/zh-hant/System.Globalization.Calendars.xml", + "ref/xamarinios10/_._", + "ref/xamarinmac20/_._", + "ref/xamarintvos10/_._", + "ref/xamarinwatchos10/_._" + ] + }, + "System.Globalization.Extensions/4.0.1": { + "sha512": "KKo23iKeOaIg61SSXwjANN7QYDr/3op3OWGGzDzz7mypx0Za0fZSeG0l6cco8Ntp8YMYkIQcAqlk8yhm5/Uhcg==", + "type": "package", + "path": "System.Globalization.Extensions/4.0.1", + "files": [ + "System.Globalization.Extensions.4.0.1.nupkg.sha512", + "System.Globalization.Extensions.nuspec", + "ThirdPartyNotices.txt", + "dotnet_library_license.txt", + "lib/MonoAndroid10/_._", + "lib/MonoTouch10/_._", + "lib/net46/System.Globalization.Extensions.dll", + "lib/xamarinios10/_._", + "lib/xamarinmac20/_._", + "lib/xamarintvos10/_._", + "lib/xamarinwatchos10/_._", + "ref/MonoAndroid10/_._", + "ref/MonoTouch10/_._", + "ref/net46/System.Globalization.Extensions.dll", + "ref/netstandard1.3/System.Globalization.Extensions.dll", + "ref/netstandard1.3/System.Globalization.Extensions.xml", + "ref/netstandard1.3/de/System.Globalization.Extensions.xml", + "ref/netstandard1.3/es/System.Globalization.Extensions.xml", + "ref/netstandard1.3/fr/System.Globalization.Extensions.xml", + "ref/netstandard1.3/it/System.Globalization.Extensions.xml", + "ref/netstandard1.3/ja/System.Globalization.Extensions.xml", + "ref/netstandard1.3/ko/System.Globalization.Extensions.xml", + "ref/netstandard1.3/ru/System.Globalization.Extensions.xml", + "ref/netstandard1.3/zh-hans/System.Globalization.Extensions.xml", + "ref/netstandard1.3/zh-hant/System.Globalization.Extensions.xml", + "ref/xamarinios10/_._", + "ref/xamarinmac20/_._", + "ref/xamarintvos10/_._", + "ref/xamarinwatchos10/_._", + "runtimes/unix/lib/netstandard1.3/System.Globalization.Extensions.dll", + "runtimes/win/lib/net46/System.Globalization.Extensions.dll", + "runtimes/win/lib/netstandard1.3/System.Globalization.Extensions.dll" + ] + }, + "System.IO/4.1.0": { + "sha512": "3KlTJceQc3gnGIaHZ7UBZO26SHL1SHE4ddrmiwumFnId+CEHP+O8r386tZKaE6zlk5/mF8vifMBzHj9SaXN+mQ==", + "type": "package", + "path": "System.IO/4.1.0", + "files": [ + "System.IO.4.1.0.nupkg.sha512", + "System.IO.nuspec", + "ThirdPartyNotices.txt", + "dotnet_library_license.txt", + "lib/MonoAndroid10/_._", + "lib/MonoTouch10/_._", + "lib/net45/_._", + "lib/net462/System.IO.dll", + "lib/portable-net45+win8+wp8+wpa81/_._", + "lib/win8/_._", + "lib/wp80/_._", + "lib/wpa81/_._", + "lib/xamarinios10/_._", + "lib/xamarinmac20/_._", + "lib/xamarintvos10/_._", + "lib/xamarinwatchos10/_._", + "ref/MonoAndroid10/_._", + "ref/MonoTouch10/_._", + "ref/net45/_._", + "ref/net462/System.IO.dll", + "ref/netcore50/System.IO.dll", + "ref/netcore50/System.IO.xml", + "ref/netcore50/de/System.IO.xml", + "ref/netcore50/es/System.IO.xml", + "ref/netcore50/fr/System.IO.xml", + "ref/netcore50/it/System.IO.xml", + "ref/netcore50/ja/System.IO.xml", + "ref/netcore50/ko/System.IO.xml", + "ref/netcore50/ru/System.IO.xml", + "ref/netcore50/zh-hans/System.IO.xml", + "ref/netcore50/zh-hant/System.IO.xml", + "ref/netstandard1.0/System.IO.dll", + "ref/netstandard1.0/System.IO.xml", + "ref/netstandard1.0/de/System.IO.xml", + "ref/netstandard1.0/es/System.IO.xml", + "ref/netstandard1.0/fr/System.IO.xml", + "ref/netstandard1.0/it/System.IO.xml", + "ref/netstandard1.0/ja/System.IO.xml", + "ref/netstandard1.0/ko/System.IO.xml", + "ref/netstandard1.0/ru/System.IO.xml", + "ref/netstandard1.0/zh-hans/System.IO.xml", + "ref/netstandard1.0/zh-hant/System.IO.xml", + "ref/netstandard1.3/System.IO.dll", + "ref/netstandard1.3/System.IO.xml", + "ref/netstandard1.3/de/System.IO.xml", + "ref/netstandard1.3/es/System.IO.xml", + "ref/netstandard1.3/fr/System.IO.xml", + "ref/netstandard1.3/it/System.IO.xml", + "ref/netstandard1.3/ja/System.IO.xml", + "ref/netstandard1.3/ko/System.IO.xml", + "ref/netstandard1.3/ru/System.IO.xml", + "ref/netstandard1.3/zh-hans/System.IO.xml", + "ref/netstandard1.3/zh-hant/System.IO.xml", + "ref/netstandard1.5/System.IO.dll", + "ref/netstandard1.5/System.IO.xml", + "ref/netstandard1.5/de/System.IO.xml", + "ref/netstandard1.5/es/System.IO.xml", + "ref/netstandard1.5/fr/System.IO.xml", + "ref/netstandard1.5/it/System.IO.xml", + "ref/netstandard1.5/ja/System.IO.xml", + "ref/netstandard1.5/ko/System.IO.xml", + "ref/netstandard1.5/ru/System.IO.xml", + "ref/netstandard1.5/zh-hans/System.IO.xml", + "ref/netstandard1.5/zh-hant/System.IO.xml", + "ref/portable-net45+win8+wp8+wpa81/_._", + "ref/win8/_._", + "ref/wp80/_._", + "ref/wpa81/_._", + "ref/xamarinios10/_._", + "ref/xamarinmac20/_._", + "ref/xamarintvos10/_._", + "ref/xamarinwatchos10/_._" + ] + }, + "System.IO.Compression/4.1.0": { + "sha512": "TjnBS6eztThSzeSib+WyVbLzEdLKUcEHN69VtS3u8aAsSc18FU6xCZlNWWsEd8SKcXAE+y1sOu7VbU8sUeM0sg==", + "type": "package", + "path": "System.IO.Compression/4.1.0", + "files": [ + "System.IO.Compression.4.1.0.nupkg.sha512", + "System.IO.Compression.nuspec", + "ThirdPartyNotices.txt", + "dotnet_library_license.txt", + "lib/MonoAndroid10/_._", + "lib/MonoTouch10/_._", + "lib/net45/_._", + "lib/net46/System.IO.Compression.dll", + "lib/portable-net45+win8+wpa81/_._", + "lib/win8/_._", + "lib/wpa81/_._", + "lib/xamarinios10/_._", + "lib/xamarinmac20/_._", + "lib/xamarintvos10/_._", + "lib/xamarinwatchos10/_._", + "ref/MonoAndroid10/_._", + "ref/MonoTouch10/_._", + "ref/net45/_._", + "ref/net46/System.IO.Compression.dll", + "ref/netcore50/System.IO.Compression.dll", + "ref/netcore50/System.IO.Compression.xml", + "ref/netcore50/de/System.IO.Compression.xml", + "ref/netcore50/es/System.IO.Compression.xml", + "ref/netcore50/fr/System.IO.Compression.xml", + "ref/netcore50/it/System.IO.Compression.xml", + "ref/netcore50/ja/System.IO.Compression.xml", + "ref/netcore50/ko/System.IO.Compression.xml", + "ref/netcore50/ru/System.IO.Compression.xml", + "ref/netcore50/zh-hans/System.IO.Compression.xml", + "ref/netcore50/zh-hant/System.IO.Compression.xml", + "ref/netstandard1.1/System.IO.Compression.dll", + "ref/netstandard1.1/System.IO.Compression.xml", + "ref/netstandard1.1/de/System.IO.Compression.xml", + "ref/netstandard1.1/es/System.IO.Compression.xml", + "ref/netstandard1.1/fr/System.IO.Compression.xml", + "ref/netstandard1.1/it/System.IO.Compression.xml", + "ref/netstandard1.1/ja/System.IO.Compression.xml", + "ref/netstandard1.1/ko/System.IO.Compression.xml", + "ref/netstandard1.1/ru/System.IO.Compression.xml", + "ref/netstandard1.1/zh-hans/System.IO.Compression.xml", + "ref/netstandard1.1/zh-hant/System.IO.Compression.xml", + "ref/netstandard1.3/System.IO.Compression.dll", + "ref/netstandard1.3/System.IO.Compression.xml", + "ref/netstandard1.3/de/System.IO.Compression.xml", + "ref/netstandard1.3/es/System.IO.Compression.xml", + "ref/netstandard1.3/fr/System.IO.Compression.xml", + "ref/netstandard1.3/it/System.IO.Compression.xml", + "ref/netstandard1.3/ja/System.IO.Compression.xml", + "ref/netstandard1.3/ko/System.IO.Compression.xml", + "ref/netstandard1.3/ru/System.IO.Compression.xml", + "ref/netstandard1.3/zh-hans/System.IO.Compression.xml", + "ref/netstandard1.3/zh-hant/System.IO.Compression.xml", + "ref/portable-net45+win8+wpa81/_._", + "ref/win8/_._", + "ref/wpa81/_._", + "ref/xamarinios10/_._", + "ref/xamarinmac20/_._", + "ref/xamarintvos10/_._", + "ref/xamarinwatchos10/_._", + "runtimes/unix/lib/netstandard1.3/System.IO.Compression.dll", + "runtimes/win/lib/net46/System.IO.Compression.dll", + "runtimes/win/lib/netstandard1.3/System.IO.Compression.dll" + ] + }, + "System.IO.Compression.ZipFile/4.0.1": { + "sha512": "hBQYJzfTbQURF10nLhd+az2NHxsU6MU7AB8RUf4IolBP5lOAm4Luho851xl+CqslmhI5ZH/el8BlngEk4lBkaQ==", + "type": "package", + "path": "System.IO.Compression.ZipFile/4.0.1", + "files": [ + "System.IO.Compression.ZipFile.4.0.1.nupkg.sha512", + "System.IO.Compression.ZipFile.nuspec", + "ThirdPartyNotices.txt", + "dotnet_library_license.txt", + "lib/MonoAndroid10/_._", + "lib/MonoTouch10/_._", + "lib/net46/System.IO.Compression.ZipFile.dll", + "lib/netstandard1.3/System.IO.Compression.ZipFile.dll", + "lib/xamarinios10/_._", + "lib/xamarinmac20/_._", + "lib/xamarintvos10/_._", + "lib/xamarinwatchos10/_._", + "ref/MonoAndroid10/_._", + "ref/MonoTouch10/_._", + "ref/net46/System.IO.Compression.ZipFile.dll", + "ref/netstandard1.3/System.IO.Compression.ZipFile.dll", + "ref/netstandard1.3/System.IO.Compression.ZipFile.xml", + "ref/netstandard1.3/de/System.IO.Compression.ZipFile.xml", + "ref/netstandard1.3/es/System.IO.Compression.ZipFile.xml", + "ref/netstandard1.3/fr/System.IO.Compression.ZipFile.xml", + "ref/netstandard1.3/it/System.IO.Compression.ZipFile.xml", + "ref/netstandard1.3/ja/System.IO.Compression.ZipFile.xml", + "ref/netstandard1.3/ko/System.IO.Compression.ZipFile.xml", + "ref/netstandard1.3/ru/System.IO.Compression.ZipFile.xml", + "ref/netstandard1.3/zh-hans/System.IO.Compression.ZipFile.xml", + "ref/netstandard1.3/zh-hant/System.IO.Compression.ZipFile.xml", + "ref/xamarinios10/_._", + "ref/xamarinmac20/_._", + "ref/xamarintvos10/_._", + "ref/xamarinwatchos10/_._" + ] + }, + "System.IO.FileSystem/4.0.1": { + "sha512": "IBErlVq5jOggAD69bg1t0pJcHaDbJbWNUZTPI96fkYWzwYbN6D9wRHMULLDd9dHsl7C2YsxXL31LMfPI1SWt8w==", + "type": "package", + "path": "System.IO.FileSystem/4.0.1", + "files": [ + "System.IO.FileSystem.4.0.1.nupkg.sha512", + "System.IO.FileSystem.nuspec", + "ThirdPartyNotices.txt", + "dotnet_library_license.txt", + "lib/MonoAndroid10/_._", + "lib/MonoTouch10/_._", + "lib/net46/System.IO.FileSystem.dll", + "lib/xamarinios10/_._", + "lib/xamarinmac20/_._", + "lib/xamarintvos10/_._", + "lib/xamarinwatchos10/_._", + "ref/MonoAndroid10/_._", + "ref/MonoTouch10/_._", + "ref/net46/System.IO.FileSystem.dll", + "ref/netstandard1.3/System.IO.FileSystem.dll", + "ref/netstandard1.3/System.IO.FileSystem.xml", + "ref/netstandard1.3/de/System.IO.FileSystem.xml", + "ref/netstandard1.3/es/System.IO.FileSystem.xml", + "ref/netstandard1.3/fr/System.IO.FileSystem.xml", + "ref/netstandard1.3/it/System.IO.FileSystem.xml", + "ref/netstandard1.3/ja/System.IO.FileSystem.xml", + "ref/netstandard1.3/ko/System.IO.FileSystem.xml", + "ref/netstandard1.3/ru/System.IO.FileSystem.xml", + "ref/netstandard1.3/zh-hans/System.IO.FileSystem.xml", + "ref/netstandard1.3/zh-hant/System.IO.FileSystem.xml", + "ref/xamarinios10/_._", + "ref/xamarinmac20/_._", + "ref/xamarintvos10/_._", + "ref/xamarinwatchos10/_._" + ] + }, + "System.IO.FileSystem.Primitives/4.0.1": { + "sha512": "kWkKD203JJKxJeE74p8aF8y4Qc9r9WQx4C0cHzHPrY3fv/L/IhWnyCHaFJ3H1QPOH6A93whlQ2vG5nHlBDvzWQ==", + "type": "package", + "path": "System.IO.FileSystem.Primitives/4.0.1", + "files": [ + "System.IO.FileSystem.Primitives.4.0.1.nupkg.sha512", + "System.IO.FileSystem.Primitives.nuspec", + "ThirdPartyNotices.txt", + "dotnet_library_license.txt", + "lib/MonoAndroid10/_._", + "lib/MonoTouch10/_._", + "lib/net46/System.IO.FileSystem.Primitives.dll", + "lib/netstandard1.3/System.IO.FileSystem.Primitives.dll", + "lib/xamarinios10/_._", + "lib/xamarinmac20/_._", + "lib/xamarintvos10/_._", + "lib/xamarinwatchos10/_._", + "ref/MonoAndroid10/_._", + "ref/MonoTouch10/_._", + "ref/net46/System.IO.FileSystem.Primitives.dll", + "ref/netstandard1.3/System.IO.FileSystem.Primitives.dll", + "ref/netstandard1.3/System.IO.FileSystem.Primitives.xml", + "ref/netstandard1.3/de/System.IO.FileSystem.Primitives.xml", + "ref/netstandard1.3/es/System.IO.FileSystem.Primitives.xml", + "ref/netstandard1.3/fr/System.IO.FileSystem.Primitives.xml", + "ref/netstandard1.3/it/System.IO.FileSystem.Primitives.xml", + "ref/netstandard1.3/ja/System.IO.FileSystem.Primitives.xml", + "ref/netstandard1.3/ko/System.IO.FileSystem.Primitives.xml", + "ref/netstandard1.3/ru/System.IO.FileSystem.Primitives.xml", + "ref/netstandard1.3/zh-hans/System.IO.FileSystem.Primitives.xml", + "ref/netstandard1.3/zh-hant/System.IO.FileSystem.Primitives.xml", + "ref/xamarinios10/_._", + "ref/xamarinmac20/_._", + "ref/xamarintvos10/_._", + "ref/xamarinwatchos10/_._" + ] + }, + "System.Linq/4.1.0": { + "sha512": "bQ0iYFOQI0nuTnt+NQADns6ucV4DUvMdwN6CbkB1yj8i7arTGiTN5eok1kQwdnnNWSDZfIUySQY+J3d5KjWn0g==", + "type": "package", + "path": "System.Linq/4.1.0", + "files": [ + "System.Linq.4.1.0.nupkg.sha512", + "System.Linq.nuspec", + "ThirdPartyNotices.txt", + "dotnet_library_license.txt", + "lib/MonoAndroid10/_._", + "lib/MonoTouch10/_._", + "lib/net45/_._", + "lib/net463/System.Linq.dll", + "lib/netcore50/System.Linq.dll", + "lib/netstandard1.6/System.Linq.dll", + "lib/portable-net45+win8+wp8+wpa81/_._", + "lib/win8/_._", + "lib/wp80/_._", + "lib/wpa81/_._", + "lib/xamarinios10/_._", + "lib/xamarinmac20/_._", + "lib/xamarintvos10/_._", + "lib/xamarinwatchos10/_._", + "ref/MonoAndroid10/_._", + "ref/MonoTouch10/_._", + "ref/net45/_._", + "ref/net463/System.Linq.dll", + "ref/netcore50/System.Linq.dll", + "ref/netcore50/System.Linq.xml", + "ref/netcore50/de/System.Linq.xml", + "ref/netcore50/es/System.Linq.xml", + "ref/netcore50/fr/System.Linq.xml", + "ref/netcore50/it/System.Linq.xml", + "ref/netcore50/ja/System.Linq.xml", + "ref/netcore50/ko/System.Linq.xml", + "ref/netcore50/ru/System.Linq.xml", + "ref/netcore50/zh-hans/System.Linq.xml", + "ref/netcore50/zh-hant/System.Linq.xml", + "ref/netstandard1.0/System.Linq.dll", + "ref/netstandard1.0/System.Linq.xml", + "ref/netstandard1.0/de/System.Linq.xml", + "ref/netstandard1.0/es/System.Linq.xml", + "ref/netstandard1.0/fr/System.Linq.xml", + "ref/netstandard1.0/it/System.Linq.xml", + "ref/netstandard1.0/ja/System.Linq.xml", + "ref/netstandard1.0/ko/System.Linq.xml", + "ref/netstandard1.0/ru/System.Linq.xml", + "ref/netstandard1.0/zh-hans/System.Linq.xml", + "ref/netstandard1.0/zh-hant/System.Linq.xml", + "ref/netstandard1.6/System.Linq.dll", + "ref/netstandard1.6/System.Linq.xml", + "ref/netstandard1.6/de/System.Linq.xml", + "ref/netstandard1.6/es/System.Linq.xml", + "ref/netstandard1.6/fr/System.Linq.xml", + "ref/netstandard1.6/it/System.Linq.xml", + "ref/netstandard1.6/ja/System.Linq.xml", + "ref/netstandard1.6/ko/System.Linq.xml", + "ref/netstandard1.6/ru/System.Linq.xml", + "ref/netstandard1.6/zh-hans/System.Linq.xml", + "ref/netstandard1.6/zh-hant/System.Linq.xml", + "ref/portable-net45+win8+wp8+wpa81/_._", + "ref/win8/_._", + "ref/wp80/_._", + "ref/wpa81/_._", + "ref/xamarinios10/_._", + "ref/xamarinmac20/_._", + "ref/xamarintvos10/_._", + "ref/xamarinwatchos10/_._" + ] + }, + "System.Linq.Expressions/4.1.0": { + "sha512": "I+y02iqkgmCAyfbqOmSDOgqdZQ5tTj80Akm5BPSS8EeB0VGWdy6X1KCoYe8Pk6pwDoAKZUOdLVxnTJcExiv5zw==", + "type": "package", + "path": "System.Linq.Expressions/4.1.0", + "files": [ + "System.Linq.Expressions.4.1.0.nupkg.sha512", + "System.Linq.Expressions.nuspec", + "ThirdPartyNotices.txt", + "dotnet_library_license.txt", + "lib/MonoAndroid10/_._", + "lib/MonoTouch10/_._", + "lib/net45/_._", + "lib/net463/System.Linq.Expressions.dll", + "lib/netcore50/System.Linq.Expressions.dll", + "lib/netstandard1.6/System.Linq.Expressions.dll", + "lib/portable-net45+win8+wp8+wpa81/_._", + "lib/win8/_._", + "lib/wp80/_._", + "lib/wpa81/_._", + "lib/xamarinios10/_._", + "lib/xamarinmac20/_._", + "lib/xamarintvos10/_._", + "lib/xamarinwatchos10/_._", + "ref/MonoAndroid10/_._", + "ref/MonoTouch10/_._", + "ref/net45/_._", + "ref/net463/System.Linq.Expressions.dll", + "ref/netcore50/System.Linq.Expressions.dll", + "ref/netcore50/System.Linq.Expressions.xml", + "ref/netcore50/de/System.Linq.Expressions.xml", + "ref/netcore50/es/System.Linq.Expressions.xml", + "ref/netcore50/fr/System.Linq.Expressions.xml", + "ref/netcore50/it/System.Linq.Expressions.xml", + "ref/netcore50/ja/System.Linq.Expressions.xml", + "ref/netcore50/ko/System.Linq.Expressions.xml", + "ref/netcore50/ru/System.Linq.Expressions.xml", + "ref/netcore50/zh-hans/System.Linq.Expressions.xml", + "ref/netcore50/zh-hant/System.Linq.Expressions.xml", + "ref/netstandard1.0/System.Linq.Expressions.dll", + "ref/netstandard1.0/System.Linq.Expressions.xml", + "ref/netstandard1.0/de/System.Linq.Expressions.xml", + "ref/netstandard1.0/es/System.Linq.Expressions.xml", + "ref/netstandard1.0/fr/System.Linq.Expressions.xml", + "ref/netstandard1.0/it/System.Linq.Expressions.xml", + "ref/netstandard1.0/ja/System.Linq.Expressions.xml", + "ref/netstandard1.0/ko/System.Linq.Expressions.xml", + "ref/netstandard1.0/ru/System.Linq.Expressions.xml", + "ref/netstandard1.0/zh-hans/System.Linq.Expressions.xml", + "ref/netstandard1.0/zh-hant/System.Linq.Expressions.xml", + "ref/netstandard1.3/System.Linq.Expressions.dll", + "ref/netstandard1.3/System.Linq.Expressions.xml", + "ref/netstandard1.3/de/System.Linq.Expressions.xml", + "ref/netstandard1.3/es/System.Linq.Expressions.xml", + "ref/netstandard1.3/fr/System.Linq.Expressions.xml", + "ref/netstandard1.3/it/System.Linq.Expressions.xml", + "ref/netstandard1.3/ja/System.Linq.Expressions.xml", + "ref/netstandard1.3/ko/System.Linq.Expressions.xml", + "ref/netstandard1.3/ru/System.Linq.Expressions.xml", + "ref/netstandard1.3/zh-hans/System.Linq.Expressions.xml", + "ref/netstandard1.3/zh-hant/System.Linq.Expressions.xml", + "ref/netstandard1.6/System.Linq.Expressions.dll", + "ref/netstandard1.6/System.Linq.Expressions.xml", + "ref/netstandard1.6/de/System.Linq.Expressions.xml", + "ref/netstandard1.6/es/System.Linq.Expressions.xml", + "ref/netstandard1.6/fr/System.Linq.Expressions.xml", + "ref/netstandard1.6/it/System.Linq.Expressions.xml", + "ref/netstandard1.6/ja/System.Linq.Expressions.xml", + "ref/netstandard1.6/ko/System.Linq.Expressions.xml", + "ref/netstandard1.6/ru/System.Linq.Expressions.xml", + "ref/netstandard1.6/zh-hans/System.Linq.Expressions.xml", + "ref/netstandard1.6/zh-hant/System.Linq.Expressions.xml", + "ref/portable-net45+win8+wp8+wpa81/_._", + "ref/win8/_._", + "ref/wp80/_._", + "ref/wpa81/_._", + "ref/xamarinios10/_._", + "ref/xamarinmac20/_._", + "ref/xamarintvos10/_._", + "ref/xamarinwatchos10/_._", + "runtimes/aot/lib/netcore50/System.Linq.Expressions.dll" + ] + }, + "System.Net.Http/4.1.0": { + "sha512": "ULq9g3SOPVuupt+Y3U+A37coXzdNisB1neFCSKzBwo182u0RDddKJF8I5+HfyXqK6OhJPgeoAwWXrbiUXuRDsg==", + "type": "package", + "path": "System.Net.Http/4.1.0", + "files": [ + "System.Net.Http.4.1.0.nupkg.sha512", + "System.Net.Http.nuspec", + "ThirdPartyNotices.txt", + "dotnet_library_license.txt", + "lib/Xamarinmac20/_._", + "lib/monoandroid10/_._", + "lib/monotouch10/_._", + "lib/net45/_._", + "lib/net46/System.Net.Http.dll", + "lib/portable-net45+win8+wpa81/_._", + "lib/win8/_._", + "lib/wpa81/_._", + "lib/xamarinios10/_._", + "lib/xamarintvos10/_._", + "lib/xamarinwatchos10/_._", + "ref/Xamarinmac20/_._", + "ref/monoandroid10/_._", + "ref/monotouch10/_._", + "ref/net45/_._", + "ref/net46/System.Net.Http.dll", + "ref/net46/System.Net.Http.xml", + "ref/net46/de/System.Net.Http.xml", + "ref/net46/es/System.Net.Http.xml", + "ref/net46/fr/System.Net.Http.xml", + "ref/net46/it/System.Net.Http.xml", + "ref/net46/ja/System.Net.Http.xml", + "ref/net46/ko/System.Net.Http.xml", + "ref/net46/ru/System.Net.Http.xml", + "ref/net46/zh-hans/System.Net.Http.xml", + "ref/net46/zh-hant/System.Net.Http.xml", + "ref/netcore50/System.Net.Http.dll", + "ref/netcore50/System.Net.Http.xml", + "ref/netcore50/de/System.Net.Http.xml", + "ref/netcore50/es/System.Net.Http.xml", + "ref/netcore50/fr/System.Net.Http.xml", + "ref/netcore50/it/System.Net.Http.xml", + "ref/netcore50/ja/System.Net.Http.xml", + "ref/netcore50/ko/System.Net.Http.xml", + "ref/netcore50/ru/System.Net.Http.xml", + "ref/netcore50/zh-hans/System.Net.Http.xml", + "ref/netcore50/zh-hant/System.Net.Http.xml", + "ref/netstandard1.1/System.Net.Http.dll", + "ref/netstandard1.1/System.Net.Http.xml", + "ref/netstandard1.1/de/System.Net.Http.xml", + "ref/netstandard1.1/es/System.Net.Http.xml", + "ref/netstandard1.1/fr/System.Net.Http.xml", + "ref/netstandard1.1/it/System.Net.Http.xml", + "ref/netstandard1.1/ja/System.Net.Http.xml", + "ref/netstandard1.1/ko/System.Net.Http.xml", + "ref/netstandard1.1/ru/System.Net.Http.xml", + "ref/netstandard1.1/zh-hans/System.Net.Http.xml", + "ref/netstandard1.1/zh-hant/System.Net.Http.xml", + "ref/netstandard1.3/System.Net.Http.dll", + "ref/netstandard1.3/System.Net.Http.xml", + "ref/netstandard1.3/de/System.Net.Http.xml", + "ref/netstandard1.3/es/System.Net.Http.xml", + "ref/netstandard1.3/fr/System.Net.Http.xml", + "ref/netstandard1.3/it/System.Net.Http.xml", + "ref/netstandard1.3/ja/System.Net.Http.xml", + "ref/netstandard1.3/ko/System.Net.Http.xml", + "ref/netstandard1.3/ru/System.Net.Http.xml", + "ref/netstandard1.3/zh-hans/System.Net.Http.xml", + "ref/netstandard1.3/zh-hant/System.Net.Http.xml", + "ref/portable-net45+win8+wpa81/_._", + "ref/win8/_._", + "ref/wpa81/_._", + "ref/xamarinios10/_._", + "ref/xamarintvos10/_._", + "ref/xamarinwatchos10/_._", + "runtimes/unix/lib/netstandard1.6/System.Net.Http.dll", + "runtimes/win/lib/net46/System.Net.Http.dll", + "runtimes/win/lib/netcore50/System.Net.Http.dll", + "runtimes/win/lib/netstandard1.3/System.Net.Http.dll" + ] + }, + "System.Net.Primitives/4.0.11": { + "sha512": "hVvfl4405DRjA2408luZekbPhplJK03j2Y2lSfMlny7GHXlkByw1iLnc9mgKW0GdQn73vvMcWrWewAhylXA4Nw==", + "type": "package", + "path": "System.Net.Primitives/4.0.11", + "files": [ + "System.Net.Primitives.4.0.11.nupkg.sha512", + "System.Net.Primitives.nuspec", + "ThirdPartyNotices.txt", + "dotnet_library_license.txt", + "lib/MonoAndroid10/_._", + "lib/MonoTouch10/_._", + "lib/net45/_._", + "lib/portable-net45+win8+wp8+wpa81/_._", + "lib/win8/_._", + "lib/wp80/_._", + "lib/wpa81/_._", + "lib/xamarinios10/_._", + "lib/xamarinmac20/_._", + "lib/xamarintvos10/_._", + "lib/xamarinwatchos10/_._", + "ref/MonoAndroid10/_._", + "ref/MonoTouch10/_._", + "ref/net45/_._", + "ref/netcore50/System.Net.Primitives.dll", + "ref/netcore50/System.Net.Primitives.xml", + "ref/netcore50/de/System.Net.Primitives.xml", + "ref/netcore50/es/System.Net.Primitives.xml", + "ref/netcore50/fr/System.Net.Primitives.xml", + "ref/netcore50/it/System.Net.Primitives.xml", + "ref/netcore50/ja/System.Net.Primitives.xml", + "ref/netcore50/ko/System.Net.Primitives.xml", + "ref/netcore50/ru/System.Net.Primitives.xml", + "ref/netcore50/zh-hans/System.Net.Primitives.xml", + "ref/netcore50/zh-hant/System.Net.Primitives.xml", + "ref/netstandard1.0/System.Net.Primitives.dll", + "ref/netstandard1.0/System.Net.Primitives.xml", + "ref/netstandard1.0/de/System.Net.Primitives.xml", + "ref/netstandard1.0/es/System.Net.Primitives.xml", + "ref/netstandard1.0/fr/System.Net.Primitives.xml", + "ref/netstandard1.0/it/System.Net.Primitives.xml", + "ref/netstandard1.0/ja/System.Net.Primitives.xml", + "ref/netstandard1.0/ko/System.Net.Primitives.xml", + "ref/netstandard1.0/ru/System.Net.Primitives.xml", + "ref/netstandard1.0/zh-hans/System.Net.Primitives.xml", + "ref/netstandard1.0/zh-hant/System.Net.Primitives.xml", + "ref/netstandard1.1/System.Net.Primitives.dll", + "ref/netstandard1.1/System.Net.Primitives.xml", + "ref/netstandard1.1/de/System.Net.Primitives.xml", + "ref/netstandard1.1/es/System.Net.Primitives.xml", + "ref/netstandard1.1/fr/System.Net.Primitives.xml", + "ref/netstandard1.1/it/System.Net.Primitives.xml", + "ref/netstandard1.1/ja/System.Net.Primitives.xml", + "ref/netstandard1.1/ko/System.Net.Primitives.xml", + "ref/netstandard1.1/ru/System.Net.Primitives.xml", + "ref/netstandard1.1/zh-hans/System.Net.Primitives.xml", + "ref/netstandard1.1/zh-hant/System.Net.Primitives.xml", + "ref/netstandard1.3/System.Net.Primitives.dll", + "ref/netstandard1.3/System.Net.Primitives.xml", + "ref/netstandard1.3/de/System.Net.Primitives.xml", + "ref/netstandard1.3/es/System.Net.Primitives.xml", + "ref/netstandard1.3/fr/System.Net.Primitives.xml", + "ref/netstandard1.3/it/System.Net.Primitives.xml", + "ref/netstandard1.3/ja/System.Net.Primitives.xml", + "ref/netstandard1.3/ko/System.Net.Primitives.xml", + "ref/netstandard1.3/ru/System.Net.Primitives.xml", + "ref/netstandard1.3/zh-hans/System.Net.Primitives.xml", + "ref/netstandard1.3/zh-hant/System.Net.Primitives.xml", + "ref/portable-net45+win8+wp8+wpa81/_._", + "ref/win8/_._", + "ref/wp80/_._", + "ref/wpa81/_._", + "ref/xamarinios10/_._", + "ref/xamarinmac20/_._", + "ref/xamarintvos10/_._", + "ref/xamarinwatchos10/_._" + ] + }, + "System.Net.Sockets/4.1.0": { + "sha512": "xAz0N3dAV/aR/9g8r0Y5oEqU1JRsz29F5EGb/WVHmX3jVSLqi2/92M5hTad2aNWovruXrJpJtgZ9fccPMG9uSw==", + "type": "package", + "path": "System.Net.Sockets/4.1.0", + "files": [ + "System.Net.Sockets.4.1.0.nupkg.sha512", + "System.Net.Sockets.nuspec", + "ThirdPartyNotices.txt", + "dotnet_library_license.txt", + "lib/MonoAndroid10/_._", + "lib/MonoTouch10/_._", + "lib/net46/System.Net.Sockets.dll", + "lib/xamarinios10/_._", + "lib/xamarinmac20/_._", + "lib/xamarintvos10/_._", + "lib/xamarinwatchos10/_._", + "ref/MonoAndroid10/_._", + "ref/MonoTouch10/_._", + "ref/net46/System.Net.Sockets.dll", + "ref/netstandard1.3/System.Net.Sockets.dll", + "ref/netstandard1.3/System.Net.Sockets.xml", + "ref/netstandard1.3/de/System.Net.Sockets.xml", + "ref/netstandard1.3/es/System.Net.Sockets.xml", + "ref/netstandard1.3/fr/System.Net.Sockets.xml", + "ref/netstandard1.3/it/System.Net.Sockets.xml", + "ref/netstandard1.3/ja/System.Net.Sockets.xml", + "ref/netstandard1.3/ko/System.Net.Sockets.xml", + "ref/netstandard1.3/ru/System.Net.Sockets.xml", + "ref/netstandard1.3/zh-hans/System.Net.Sockets.xml", + "ref/netstandard1.3/zh-hant/System.Net.Sockets.xml", + "ref/xamarinios10/_._", + "ref/xamarinmac20/_._", + "ref/xamarintvos10/_._", + "ref/xamarinwatchos10/_._" + ] + }, + "System.ObjectModel/4.0.12": { + "sha512": "tAgJM1xt3ytyMoW4qn4wIqgJYm7L7TShRZG4+Q4Qsi2PCcj96pXN7nRywS9KkB3p/xDUjc2HSwP9SROyPYDYKQ==", + "type": "package", + "path": "System.ObjectModel/4.0.12", + "files": [ + "System.ObjectModel.4.0.12.nupkg.sha512", + "System.ObjectModel.nuspec", + "ThirdPartyNotices.txt", + "dotnet_library_license.txt", + "lib/MonoAndroid10/_._", + "lib/MonoTouch10/_._", + "lib/net45/_._", + "lib/netcore50/System.ObjectModel.dll", + "lib/netstandard1.3/System.ObjectModel.dll", + "lib/portable-net45+win8+wp8+wpa81/_._", + "lib/win8/_._", + "lib/wp80/_._", + "lib/wpa81/_._", + "lib/xamarinios10/_._", + "lib/xamarinmac20/_._", + "lib/xamarintvos10/_._", + "lib/xamarinwatchos10/_._", + "ref/MonoAndroid10/_._", + "ref/MonoTouch10/_._", + "ref/net45/_._", + "ref/netcore50/System.ObjectModel.dll", + "ref/netcore50/System.ObjectModel.xml", + "ref/netcore50/de/System.ObjectModel.xml", + "ref/netcore50/es/System.ObjectModel.xml", + "ref/netcore50/fr/System.ObjectModel.xml", + "ref/netcore50/it/System.ObjectModel.xml", + "ref/netcore50/ja/System.ObjectModel.xml", + "ref/netcore50/ko/System.ObjectModel.xml", + "ref/netcore50/ru/System.ObjectModel.xml", + "ref/netcore50/zh-hans/System.ObjectModel.xml", + "ref/netcore50/zh-hant/System.ObjectModel.xml", + "ref/netstandard1.0/System.ObjectModel.dll", + "ref/netstandard1.0/System.ObjectModel.xml", + "ref/netstandard1.0/de/System.ObjectModel.xml", + "ref/netstandard1.0/es/System.ObjectModel.xml", + "ref/netstandard1.0/fr/System.ObjectModel.xml", + "ref/netstandard1.0/it/System.ObjectModel.xml", + "ref/netstandard1.0/ja/System.ObjectModel.xml", + "ref/netstandard1.0/ko/System.ObjectModel.xml", + "ref/netstandard1.0/ru/System.ObjectModel.xml", + "ref/netstandard1.0/zh-hans/System.ObjectModel.xml", + "ref/netstandard1.0/zh-hant/System.ObjectModel.xml", + "ref/netstandard1.3/System.ObjectModel.dll", + "ref/netstandard1.3/System.ObjectModel.xml", + "ref/netstandard1.3/de/System.ObjectModel.xml", + "ref/netstandard1.3/es/System.ObjectModel.xml", + "ref/netstandard1.3/fr/System.ObjectModel.xml", + "ref/netstandard1.3/it/System.ObjectModel.xml", + "ref/netstandard1.3/ja/System.ObjectModel.xml", + "ref/netstandard1.3/ko/System.ObjectModel.xml", + "ref/netstandard1.3/ru/System.ObjectModel.xml", + "ref/netstandard1.3/zh-hans/System.ObjectModel.xml", + "ref/netstandard1.3/zh-hant/System.ObjectModel.xml", + "ref/portable-net45+win8+wp8+wpa81/_._", + "ref/win8/_._", + "ref/wp80/_._", + "ref/wpa81/_._", + "ref/xamarinios10/_._", + "ref/xamarinmac20/_._", + "ref/xamarintvos10/_._", + "ref/xamarinwatchos10/_._" + ] + }, + "System.Reflection/4.1.0": { + "sha512": "JCKANJ0TI7kzoQzuwB/OoJANy1Lg338B6+JVacPl4TpUwi3cReg3nMLplMq2uqYfHFQpKIlHAUVAJlImZz/4ng==", + "type": "package", + "path": "System.Reflection/4.1.0", + "files": [ + "System.Reflection.4.1.0.nupkg.sha512", + "System.Reflection.nuspec", + "ThirdPartyNotices.txt", + "dotnet_library_license.txt", + "lib/MonoAndroid10/_._", + "lib/MonoTouch10/_._", + "lib/net45/_._", + "lib/net462/System.Reflection.dll", + "lib/portable-net45+win8+wp8+wpa81/_._", + "lib/win8/_._", + "lib/wp80/_._", + "lib/wpa81/_._", + "lib/xamarinios10/_._", + "lib/xamarinmac20/_._", + "lib/xamarintvos10/_._", + "lib/xamarinwatchos10/_._", + "ref/MonoAndroid10/_._", + "ref/MonoTouch10/_._", + "ref/net45/_._", + "ref/net462/System.Reflection.dll", + "ref/netcore50/System.Reflection.dll", + "ref/netcore50/System.Reflection.xml", + "ref/netcore50/de/System.Reflection.xml", + "ref/netcore50/es/System.Reflection.xml", + "ref/netcore50/fr/System.Reflection.xml", + "ref/netcore50/it/System.Reflection.xml", + "ref/netcore50/ja/System.Reflection.xml", + "ref/netcore50/ko/System.Reflection.xml", + "ref/netcore50/ru/System.Reflection.xml", + "ref/netcore50/zh-hans/System.Reflection.xml", + "ref/netcore50/zh-hant/System.Reflection.xml", + "ref/netstandard1.0/System.Reflection.dll", + "ref/netstandard1.0/System.Reflection.xml", + "ref/netstandard1.0/de/System.Reflection.xml", + "ref/netstandard1.0/es/System.Reflection.xml", + "ref/netstandard1.0/fr/System.Reflection.xml", + "ref/netstandard1.0/it/System.Reflection.xml", + "ref/netstandard1.0/ja/System.Reflection.xml", + "ref/netstandard1.0/ko/System.Reflection.xml", + "ref/netstandard1.0/ru/System.Reflection.xml", + "ref/netstandard1.0/zh-hans/System.Reflection.xml", + "ref/netstandard1.0/zh-hant/System.Reflection.xml", + "ref/netstandard1.3/System.Reflection.dll", + "ref/netstandard1.3/System.Reflection.xml", + "ref/netstandard1.3/de/System.Reflection.xml", + "ref/netstandard1.3/es/System.Reflection.xml", + "ref/netstandard1.3/fr/System.Reflection.xml", + "ref/netstandard1.3/it/System.Reflection.xml", + "ref/netstandard1.3/ja/System.Reflection.xml", + "ref/netstandard1.3/ko/System.Reflection.xml", + "ref/netstandard1.3/ru/System.Reflection.xml", + "ref/netstandard1.3/zh-hans/System.Reflection.xml", + "ref/netstandard1.3/zh-hant/System.Reflection.xml", + "ref/netstandard1.5/System.Reflection.dll", + "ref/netstandard1.5/System.Reflection.xml", + "ref/netstandard1.5/de/System.Reflection.xml", + "ref/netstandard1.5/es/System.Reflection.xml", + "ref/netstandard1.5/fr/System.Reflection.xml", + "ref/netstandard1.5/it/System.Reflection.xml", + "ref/netstandard1.5/ja/System.Reflection.xml", + "ref/netstandard1.5/ko/System.Reflection.xml", + "ref/netstandard1.5/ru/System.Reflection.xml", + "ref/netstandard1.5/zh-hans/System.Reflection.xml", + "ref/netstandard1.5/zh-hant/System.Reflection.xml", + "ref/portable-net45+win8+wp8+wpa81/_._", + "ref/win8/_._", + "ref/wp80/_._", + "ref/wpa81/_._", + "ref/xamarinios10/_._", + "ref/xamarinmac20/_._", + "ref/xamarintvos10/_._", + "ref/xamarinwatchos10/_._" + ] + }, + "System.Reflection.Emit/4.0.1": { + "sha512": "P2wqAj72fFjpP6wb9nSfDqNBMab+2ovzSDzUZK7MVIm54tBJEPr9jWfSjjoTpPwj1LeKcmX3vr0ttyjSSFM47g==", + "type": "package", + "path": "System.Reflection.Emit/4.0.1", + "files": [ + "System.Reflection.Emit.4.0.1.nupkg.sha512", + "System.Reflection.Emit.nuspec", + "ThirdPartyNotices.txt", + "dotnet_library_license.txt", + "lib/MonoAndroid10/_._", + "lib/net45/_._", + "lib/netcore50/System.Reflection.Emit.dll", + "lib/netstandard1.3/System.Reflection.Emit.dll", + "lib/xamarinmac20/_._", + "ref/MonoAndroid10/_._", + "ref/net45/_._", + "ref/netstandard1.1/System.Reflection.Emit.dll", + "ref/netstandard1.1/System.Reflection.Emit.xml", + "ref/netstandard1.1/de/System.Reflection.Emit.xml", + "ref/netstandard1.1/es/System.Reflection.Emit.xml", + "ref/netstandard1.1/fr/System.Reflection.Emit.xml", + "ref/netstandard1.1/it/System.Reflection.Emit.xml", + "ref/netstandard1.1/ja/System.Reflection.Emit.xml", + "ref/netstandard1.1/ko/System.Reflection.Emit.xml", + "ref/netstandard1.1/ru/System.Reflection.Emit.xml", + "ref/netstandard1.1/zh-hans/System.Reflection.Emit.xml", + "ref/netstandard1.1/zh-hant/System.Reflection.Emit.xml", + "ref/xamarinmac20/_._" + ] + }, + "System.Reflection.Emit.ILGeneration/4.0.1": { + "sha512": "Ov6dU8Bu15Bc7zuqttgHF12J5lwSWyTf1S+FJouUXVMSqImLZzYaQ+vRr1rQ0OZ0HqsrwWl4dsKHELckQkVpgA==", + "type": "package", + "path": "System.Reflection.Emit.ILGeneration/4.0.1", + "files": [ + "System.Reflection.Emit.ILGeneration.4.0.1.nupkg.sha512", + "System.Reflection.Emit.ILGeneration.nuspec", + "ThirdPartyNotices.txt", + "dotnet_library_license.txt", + "lib/net45/_._", + "lib/netcore50/System.Reflection.Emit.ILGeneration.dll", + "lib/netstandard1.3/System.Reflection.Emit.ILGeneration.dll", + "lib/portable-net45+wp8/_._", + "lib/wp80/_._", + "ref/net45/_._", + "ref/netstandard1.0/System.Reflection.Emit.ILGeneration.dll", + "ref/netstandard1.0/System.Reflection.Emit.ILGeneration.xml", + "ref/netstandard1.0/de/System.Reflection.Emit.ILGeneration.xml", + "ref/netstandard1.0/es/System.Reflection.Emit.ILGeneration.xml", + "ref/netstandard1.0/fr/System.Reflection.Emit.ILGeneration.xml", + "ref/netstandard1.0/it/System.Reflection.Emit.ILGeneration.xml", + "ref/netstandard1.0/ja/System.Reflection.Emit.ILGeneration.xml", + "ref/netstandard1.0/ko/System.Reflection.Emit.ILGeneration.xml", + "ref/netstandard1.0/ru/System.Reflection.Emit.ILGeneration.xml", + "ref/netstandard1.0/zh-hans/System.Reflection.Emit.ILGeneration.xml", + "ref/netstandard1.0/zh-hant/System.Reflection.Emit.ILGeneration.xml", + "ref/portable-net45+wp8/_._", + "ref/wp80/_._", + "runtimes/aot/lib/netcore50/_._" + ] + }, + "System.Reflection.Emit.Lightweight/4.0.1": { + "sha512": "sSzHHXueZ5Uh0OLpUQprhr+ZYJrLPA2Cmr4gn0wj9+FftNKXx8RIMKvO9qnjk2ebPYUjZ+F2ulGdPOsvj+MEjA==", + "type": "package", + "path": "System.Reflection.Emit.Lightweight/4.0.1", + "files": [ + "System.Reflection.Emit.Lightweight.4.0.1.nupkg.sha512", + "System.Reflection.Emit.Lightweight.nuspec", + "ThirdPartyNotices.txt", + "dotnet_library_license.txt", + "lib/net45/_._", + "lib/netcore50/System.Reflection.Emit.Lightweight.dll", + "lib/netstandard1.3/System.Reflection.Emit.Lightweight.dll", + "lib/portable-net45+wp8/_._", + "lib/wp80/_._", + "ref/net45/_._", + "ref/netstandard1.0/System.Reflection.Emit.Lightweight.dll", + "ref/netstandard1.0/System.Reflection.Emit.Lightweight.xml", + "ref/netstandard1.0/de/System.Reflection.Emit.Lightweight.xml", + "ref/netstandard1.0/es/System.Reflection.Emit.Lightweight.xml", + "ref/netstandard1.0/fr/System.Reflection.Emit.Lightweight.xml", + "ref/netstandard1.0/it/System.Reflection.Emit.Lightweight.xml", + "ref/netstandard1.0/ja/System.Reflection.Emit.Lightweight.xml", + "ref/netstandard1.0/ko/System.Reflection.Emit.Lightweight.xml", + "ref/netstandard1.0/ru/System.Reflection.Emit.Lightweight.xml", + "ref/netstandard1.0/zh-hans/System.Reflection.Emit.Lightweight.xml", + "ref/netstandard1.0/zh-hant/System.Reflection.Emit.Lightweight.xml", + "ref/portable-net45+wp8/_._", + "ref/wp80/_._", + "runtimes/aot/lib/netcore50/_._" + ] + }, + "System.Reflection.Extensions/4.0.1": { + "sha512": "GYrtRsZcMuHF3sbmRHfMYpvxZoIN2bQGrYGerUiWLEkqdEUQZhH3TRSaC/oI4wO0II1RKBPlpIa1TOMxIcOOzQ==", + "type": "package", + "path": "System.Reflection.Extensions/4.0.1", + "files": [ + "System.Reflection.Extensions.4.0.1.nupkg.sha512", + "System.Reflection.Extensions.nuspec", + "ThirdPartyNotices.txt", + "dotnet_library_license.txt", + "lib/MonoAndroid10/_._", + "lib/MonoTouch10/_._", + "lib/net45/_._", + "lib/portable-net45+win8+wp8+wpa81/_._", + "lib/win8/_._", + "lib/wp80/_._", + "lib/wpa81/_._", + "lib/xamarinios10/_._", + "lib/xamarinmac20/_._", + "lib/xamarintvos10/_._", + "lib/xamarinwatchos10/_._", + "ref/MonoAndroid10/_._", + "ref/MonoTouch10/_._", + "ref/net45/_._", + "ref/netcore50/System.Reflection.Extensions.dll", + "ref/netcore50/System.Reflection.Extensions.xml", + "ref/netcore50/de/System.Reflection.Extensions.xml", + "ref/netcore50/es/System.Reflection.Extensions.xml", + "ref/netcore50/fr/System.Reflection.Extensions.xml", + "ref/netcore50/it/System.Reflection.Extensions.xml", + "ref/netcore50/ja/System.Reflection.Extensions.xml", + "ref/netcore50/ko/System.Reflection.Extensions.xml", + "ref/netcore50/ru/System.Reflection.Extensions.xml", + "ref/netcore50/zh-hans/System.Reflection.Extensions.xml", + "ref/netcore50/zh-hant/System.Reflection.Extensions.xml", + "ref/netstandard1.0/System.Reflection.Extensions.dll", + "ref/netstandard1.0/System.Reflection.Extensions.xml", + "ref/netstandard1.0/de/System.Reflection.Extensions.xml", + "ref/netstandard1.0/es/System.Reflection.Extensions.xml", + "ref/netstandard1.0/fr/System.Reflection.Extensions.xml", + "ref/netstandard1.0/it/System.Reflection.Extensions.xml", + "ref/netstandard1.0/ja/System.Reflection.Extensions.xml", + "ref/netstandard1.0/ko/System.Reflection.Extensions.xml", + "ref/netstandard1.0/ru/System.Reflection.Extensions.xml", + "ref/netstandard1.0/zh-hans/System.Reflection.Extensions.xml", + "ref/netstandard1.0/zh-hant/System.Reflection.Extensions.xml", + "ref/portable-net45+win8+wp8+wpa81/_._", + "ref/win8/_._", + "ref/wp80/_._", + "ref/wpa81/_._", + "ref/xamarinios10/_._", + "ref/xamarinmac20/_._", + "ref/xamarintvos10/_._", + "ref/xamarinwatchos10/_._" + ] + }, + "System.Reflection.Primitives/4.0.1": { + "sha512": "4inTox4wTBaDhB7V3mPvp9XlCbeGYWVEM9/fXALd52vNEAVisc1BoVWQPuUuD0Ga//dNbA/WeMy9u9mzLxGTHQ==", + "type": "package", + "path": "System.Reflection.Primitives/4.0.1", + "files": [ + "System.Reflection.Primitives.4.0.1.nupkg.sha512", + "System.Reflection.Primitives.nuspec", + "ThirdPartyNotices.txt", + "dotnet_library_license.txt", + "lib/MonoAndroid10/_._", + "lib/MonoTouch10/_._", + "lib/net45/_._", + "lib/portable-net45+win8+wp8+wpa81/_._", + "lib/win8/_._", + "lib/wp80/_._", + "lib/wpa81/_._", + "lib/xamarinios10/_._", + "lib/xamarinmac20/_._", + "lib/xamarintvos10/_._", + "lib/xamarinwatchos10/_._", + "ref/MonoAndroid10/_._", + "ref/MonoTouch10/_._", + "ref/net45/_._", + "ref/netcore50/System.Reflection.Primitives.dll", + "ref/netcore50/System.Reflection.Primitives.xml", + "ref/netcore50/de/System.Reflection.Primitives.xml", + "ref/netcore50/es/System.Reflection.Primitives.xml", + "ref/netcore50/fr/System.Reflection.Primitives.xml", + "ref/netcore50/it/System.Reflection.Primitives.xml", + "ref/netcore50/ja/System.Reflection.Primitives.xml", + "ref/netcore50/ko/System.Reflection.Primitives.xml", + "ref/netcore50/ru/System.Reflection.Primitives.xml", + "ref/netcore50/zh-hans/System.Reflection.Primitives.xml", + "ref/netcore50/zh-hant/System.Reflection.Primitives.xml", + "ref/netstandard1.0/System.Reflection.Primitives.dll", + "ref/netstandard1.0/System.Reflection.Primitives.xml", + "ref/netstandard1.0/de/System.Reflection.Primitives.xml", + "ref/netstandard1.0/es/System.Reflection.Primitives.xml", + "ref/netstandard1.0/fr/System.Reflection.Primitives.xml", + "ref/netstandard1.0/it/System.Reflection.Primitives.xml", + "ref/netstandard1.0/ja/System.Reflection.Primitives.xml", + "ref/netstandard1.0/ko/System.Reflection.Primitives.xml", + "ref/netstandard1.0/ru/System.Reflection.Primitives.xml", + "ref/netstandard1.0/zh-hans/System.Reflection.Primitives.xml", + "ref/netstandard1.0/zh-hant/System.Reflection.Primitives.xml", + "ref/portable-net45+win8+wp8+wpa81/_._", + "ref/win8/_._", + "ref/wp80/_._", + "ref/wpa81/_._", + "ref/xamarinios10/_._", + "ref/xamarinmac20/_._", + "ref/xamarintvos10/_._", + "ref/xamarinwatchos10/_._" + ] + }, + "System.Reflection.TypeExtensions/4.1.0": { + "sha512": "tsQ/ptQ3H5FYfON8lL4MxRk/8kFyE0A+tGPXmVP967cT/gzLHYxIejIYSxp4JmIeFHVP78g/F2FE1mUUTbDtrg==", + "type": "package", + "path": "System.Reflection.TypeExtensions/4.1.0", + "files": [ + "System.Reflection.TypeExtensions.4.1.0.nupkg.sha512", + "System.Reflection.TypeExtensions.nuspec", + "ThirdPartyNotices.txt", + "dotnet_library_license.txt", + "lib/MonoAndroid10/_._", + "lib/MonoTouch10/_._", + "lib/net46/System.Reflection.TypeExtensions.dll", + "lib/net462/System.Reflection.TypeExtensions.dll", + "lib/netcore50/System.Reflection.TypeExtensions.dll", + "lib/netstandard1.5/System.Reflection.TypeExtensions.dll", + "lib/xamarinios10/_._", + "lib/xamarinmac20/_._", + "lib/xamarintvos10/_._", + "lib/xamarinwatchos10/_._", + "ref/MonoAndroid10/_._", + "ref/MonoTouch10/_._", + "ref/net46/System.Reflection.TypeExtensions.dll", + "ref/net462/System.Reflection.TypeExtensions.dll", + "ref/netstandard1.3/System.Reflection.TypeExtensions.dll", + "ref/netstandard1.3/System.Reflection.TypeExtensions.xml", + "ref/netstandard1.3/de/System.Reflection.TypeExtensions.xml", + "ref/netstandard1.3/es/System.Reflection.TypeExtensions.xml", + "ref/netstandard1.3/fr/System.Reflection.TypeExtensions.xml", + "ref/netstandard1.3/it/System.Reflection.TypeExtensions.xml", + "ref/netstandard1.3/ja/System.Reflection.TypeExtensions.xml", + "ref/netstandard1.3/ko/System.Reflection.TypeExtensions.xml", + "ref/netstandard1.3/ru/System.Reflection.TypeExtensions.xml", + "ref/netstandard1.3/zh-hans/System.Reflection.TypeExtensions.xml", + "ref/netstandard1.3/zh-hant/System.Reflection.TypeExtensions.xml", + "ref/netstandard1.5/System.Reflection.TypeExtensions.dll", + "ref/netstandard1.5/System.Reflection.TypeExtensions.xml", + "ref/netstandard1.5/de/System.Reflection.TypeExtensions.xml", + "ref/netstandard1.5/es/System.Reflection.TypeExtensions.xml", + "ref/netstandard1.5/fr/System.Reflection.TypeExtensions.xml", + "ref/netstandard1.5/it/System.Reflection.TypeExtensions.xml", + "ref/netstandard1.5/ja/System.Reflection.TypeExtensions.xml", + "ref/netstandard1.5/ko/System.Reflection.TypeExtensions.xml", + "ref/netstandard1.5/ru/System.Reflection.TypeExtensions.xml", + "ref/netstandard1.5/zh-hans/System.Reflection.TypeExtensions.xml", + "ref/netstandard1.5/zh-hant/System.Reflection.TypeExtensions.xml", + "ref/xamarinios10/_._", + "ref/xamarinmac20/_._", + "ref/xamarintvos10/_._", + "ref/xamarinwatchos10/_._", + "runtimes/aot/lib/netcore50/System.Reflection.TypeExtensions.dll" + ] + }, + "System.Resources.ResourceManager/4.0.1": { + "sha512": "TxwVeUNoTgUOdQ09gfTjvW411MF+w9MBYL7AtNVc+HtBCFlutPLhUCdZjNkjbhj3bNQWMdHboF0KIWEOjJssbA==", + "type": "package", + "path": "System.Resources.ResourceManager/4.0.1", + "files": [ + "System.Resources.ResourceManager.4.0.1.nupkg.sha512", + "System.Resources.ResourceManager.nuspec", + "ThirdPartyNotices.txt", + "dotnet_library_license.txt", + "lib/MonoAndroid10/_._", + "lib/MonoTouch10/_._", + "lib/net45/_._", + "lib/portable-net45+win8+wp8+wpa81/_._", + "lib/win8/_._", + "lib/wp80/_._", + "lib/wpa81/_._", + "lib/xamarinios10/_._", + "lib/xamarinmac20/_._", + "lib/xamarintvos10/_._", + "lib/xamarinwatchos10/_._", + "ref/MonoAndroid10/_._", + "ref/MonoTouch10/_._", + "ref/net45/_._", + "ref/netcore50/System.Resources.ResourceManager.dll", + "ref/netcore50/System.Resources.ResourceManager.xml", + "ref/netcore50/de/System.Resources.ResourceManager.xml", + "ref/netcore50/es/System.Resources.ResourceManager.xml", + "ref/netcore50/fr/System.Resources.ResourceManager.xml", + "ref/netcore50/it/System.Resources.ResourceManager.xml", + "ref/netcore50/ja/System.Resources.ResourceManager.xml", + "ref/netcore50/ko/System.Resources.ResourceManager.xml", + "ref/netcore50/ru/System.Resources.ResourceManager.xml", + "ref/netcore50/zh-hans/System.Resources.ResourceManager.xml", + "ref/netcore50/zh-hant/System.Resources.ResourceManager.xml", + "ref/netstandard1.0/System.Resources.ResourceManager.dll", + "ref/netstandard1.0/System.Resources.ResourceManager.xml", + "ref/netstandard1.0/de/System.Resources.ResourceManager.xml", + "ref/netstandard1.0/es/System.Resources.ResourceManager.xml", + "ref/netstandard1.0/fr/System.Resources.ResourceManager.xml", + "ref/netstandard1.0/it/System.Resources.ResourceManager.xml", + "ref/netstandard1.0/ja/System.Resources.ResourceManager.xml", + "ref/netstandard1.0/ko/System.Resources.ResourceManager.xml", + "ref/netstandard1.0/ru/System.Resources.ResourceManager.xml", + "ref/netstandard1.0/zh-hans/System.Resources.ResourceManager.xml", + "ref/netstandard1.0/zh-hant/System.Resources.ResourceManager.xml", + "ref/portable-net45+win8+wp8+wpa81/_._", + "ref/win8/_._", + "ref/wp80/_._", + "ref/wpa81/_._", + "ref/xamarinios10/_._", + "ref/xamarinmac20/_._", + "ref/xamarintvos10/_._", + "ref/xamarinwatchos10/_._" + ] + }, + "System.Runtime/4.1.0": { + "sha512": "v6c/4Yaa9uWsq+JMhnOFewrYkgdNHNG2eMKuNqRn8P733rNXeRCGvV5FkkjBXn2dbVkPXOsO0xjsEeM1q2zC0g==", + "type": "package", + "path": "System.Runtime/4.1.0", + "files": [ + "System.Runtime.4.1.0.nupkg.sha512", + "System.Runtime.nuspec", + "ThirdPartyNotices.txt", + "dotnet_library_license.txt", + "lib/MonoAndroid10/_._", + "lib/MonoTouch10/_._", + "lib/net45/_._", + "lib/net462/System.Runtime.dll", + "lib/portable-net45+win8+wp80+wpa81/_._", + "lib/win8/_._", + "lib/wp80/_._", + "lib/wpa81/_._", + "lib/xamarinios10/_._", + "lib/xamarinmac20/_._", + "lib/xamarintvos10/_._", + "lib/xamarinwatchos10/_._", + "ref/MonoAndroid10/_._", + "ref/MonoTouch10/_._", + "ref/net45/_._", + "ref/net462/System.Runtime.dll", + "ref/netcore50/System.Runtime.dll", + "ref/netcore50/System.Runtime.xml", + "ref/netcore50/de/System.Runtime.xml", + "ref/netcore50/es/System.Runtime.xml", + "ref/netcore50/fr/System.Runtime.xml", + "ref/netcore50/it/System.Runtime.xml", + "ref/netcore50/ja/System.Runtime.xml", + "ref/netcore50/ko/System.Runtime.xml", + "ref/netcore50/ru/System.Runtime.xml", + "ref/netcore50/zh-hans/System.Runtime.xml", + "ref/netcore50/zh-hant/System.Runtime.xml", + "ref/netstandard1.0/System.Runtime.dll", + "ref/netstandard1.0/System.Runtime.xml", + "ref/netstandard1.0/de/System.Runtime.xml", + "ref/netstandard1.0/es/System.Runtime.xml", + "ref/netstandard1.0/fr/System.Runtime.xml", + "ref/netstandard1.0/it/System.Runtime.xml", + "ref/netstandard1.0/ja/System.Runtime.xml", + "ref/netstandard1.0/ko/System.Runtime.xml", + "ref/netstandard1.0/ru/System.Runtime.xml", + "ref/netstandard1.0/zh-hans/System.Runtime.xml", + "ref/netstandard1.0/zh-hant/System.Runtime.xml", + "ref/netstandard1.2/System.Runtime.dll", + "ref/netstandard1.2/System.Runtime.xml", + "ref/netstandard1.2/de/System.Runtime.xml", + "ref/netstandard1.2/es/System.Runtime.xml", + "ref/netstandard1.2/fr/System.Runtime.xml", + "ref/netstandard1.2/it/System.Runtime.xml", + "ref/netstandard1.2/ja/System.Runtime.xml", + "ref/netstandard1.2/ko/System.Runtime.xml", + "ref/netstandard1.2/ru/System.Runtime.xml", + "ref/netstandard1.2/zh-hans/System.Runtime.xml", + "ref/netstandard1.2/zh-hant/System.Runtime.xml", + "ref/netstandard1.3/System.Runtime.dll", + "ref/netstandard1.3/System.Runtime.xml", + "ref/netstandard1.3/de/System.Runtime.xml", + "ref/netstandard1.3/es/System.Runtime.xml", + "ref/netstandard1.3/fr/System.Runtime.xml", + "ref/netstandard1.3/it/System.Runtime.xml", + "ref/netstandard1.3/ja/System.Runtime.xml", + "ref/netstandard1.3/ko/System.Runtime.xml", + "ref/netstandard1.3/ru/System.Runtime.xml", + "ref/netstandard1.3/zh-hans/System.Runtime.xml", + "ref/netstandard1.3/zh-hant/System.Runtime.xml", + "ref/netstandard1.5/System.Runtime.dll", + "ref/netstandard1.5/System.Runtime.xml", + "ref/netstandard1.5/de/System.Runtime.xml", + "ref/netstandard1.5/es/System.Runtime.xml", + "ref/netstandard1.5/fr/System.Runtime.xml", + "ref/netstandard1.5/it/System.Runtime.xml", + "ref/netstandard1.5/ja/System.Runtime.xml", + "ref/netstandard1.5/ko/System.Runtime.xml", + "ref/netstandard1.5/ru/System.Runtime.xml", + "ref/netstandard1.5/zh-hans/System.Runtime.xml", + "ref/netstandard1.5/zh-hant/System.Runtime.xml", + "ref/portable-net45+win8+wp80+wpa81/_._", + "ref/win8/_._", + "ref/wp80/_._", + "ref/wpa81/_._", + "ref/xamarinios10/_._", + "ref/xamarinmac20/_._", + "ref/xamarintvos10/_._", + "ref/xamarinwatchos10/_._" + ] + }, + "System.Runtime.Extensions/4.1.0": { + "sha512": "CUOHjTT/vgP0qGW22U4/hDlOqXmcPq5YicBaXdUR2UiUoLwBT+olO6we4DVbq57jeX5uXH2uerVZhf0qGj+sVQ==", + "type": "package", + "path": "System.Runtime.Extensions/4.1.0", + "files": [ + "System.Runtime.Extensions.4.1.0.nupkg.sha512", + "System.Runtime.Extensions.nuspec", + "ThirdPartyNotices.txt", + "dotnet_library_license.txt", + "lib/MonoAndroid10/_._", + "lib/MonoTouch10/_._", + "lib/net45/_._", + "lib/net462/System.Runtime.Extensions.dll", + "lib/portable-net45+win8+wp8+wpa81/_._", + "lib/win8/_._", + "lib/wp80/_._", + "lib/wpa81/_._", + "lib/xamarinios10/_._", + "lib/xamarinmac20/_._", + "lib/xamarintvos10/_._", + "lib/xamarinwatchos10/_._", + "ref/MonoAndroid10/_._", + "ref/MonoTouch10/_._", + "ref/net45/_._", + "ref/net462/System.Runtime.Extensions.dll", + "ref/netcore50/System.Runtime.Extensions.dll", + "ref/netcore50/System.Runtime.Extensions.xml", + "ref/netcore50/de/System.Runtime.Extensions.xml", + "ref/netcore50/es/System.Runtime.Extensions.xml", + "ref/netcore50/fr/System.Runtime.Extensions.xml", + "ref/netcore50/it/System.Runtime.Extensions.xml", + "ref/netcore50/ja/System.Runtime.Extensions.xml", + "ref/netcore50/ko/System.Runtime.Extensions.xml", + "ref/netcore50/ru/System.Runtime.Extensions.xml", + "ref/netcore50/zh-hans/System.Runtime.Extensions.xml", + "ref/netcore50/zh-hant/System.Runtime.Extensions.xml", + "ref/netstandard1.0/System.Runtime.Extensions.dll", + "ref/netstandard1.0/System.Runtime.Extensions.xml", + "ref/netstandard1.0/de/System.Runtime.Extensions.xml", + "ref/netstandard1.0/es/System.Runtime.Extensions.xml", + "ref/netstandard1.0/fr/System.Runtime.Extensions.xml", + "ref/netstandard1.0/it/System.Runtime.Extensions.xml", + "ref/netstandard1.0/ja/System.Runtime.Extensions.xml", + "ref/netstandard1.0/ko/System.Runtime.Extensions.xml", + "ref/netstandard1.0/ru/System.Runtime.Extensions.xml", + "ref/netstandard1.0/zh-hans/System.Runtime.Extensions.xml", + "ref/netstandard1.0/zh-hant/System.Runtime.Extensions.xml", + "ref/netstandard1.3/System.Runtime.Extensions.dll", + "ref/netstandard1.3/System.Runtime.Extensions.xml", + "ref/netstandard1.3/de/System.Runtime.Extensions.xml", + "ref/netstandard1.3/es/System.Runtime.Extensions.xml", + "ref/netstandard1.3/fr/System.Runtime.Extensions.xml", + "ref/netstandard1.3/it/System.Runtime.Extensions.xml", + "ref/netstandard1.3/ja/System.Runtime.Extensions.xml", + "ref/netstandard1.3/ko/System.Runtime.Extensions.xml", + "ref/netstandard1.3/ru/System.Runtime.Extensions.xml", + "ref/netstandard1.3/zh-hans/System.Runtime.Extensions.xml", + "ref/netstandard1.3/zh-hant/System.Runtime.Extensions.xml", + "ref/netstandard1.5/System.Runtime.Extensions.dll", + "ref/netstandard1.5/System.Runtime.Extensions.xml", + "ref/netstandard1.5/de/System.Runtime.Extensions.xml", + "ref/netstandard1.5/es/System.Runtime.Extensions.xml", + "ref/netstandard1.5/fr/System.Runtime.Extensions.xml", + "ref/netstandard1.5/it/System.Runtime.Extensions.xml", + "ref/netstandard1.5/ja/System.Runtime.Extensions.xml", + "ref/netstandard1.5/ko/System.Runtime.Extensions.xml", + "ref/netstandard1.5/ru/System.Runtime.Extensions.xml", + "ref/netstandard1.5/zh-hans/System.Runtime.Extensions.xml", + "ref/netstandard1.5/zh-hant/System.Runtime.Extensions.xml", + "ref/portable-net45+win8+wp8+wpa81/_._", + "ref/win8/_._", + "ref/wp80/_._", + "ref/wpa81/_._", + "ref/xamarinios10/_._", + "ref/xamarinmac20/_._", + "ref/xamarintvos10/_._", + "ref/xamarinwatchos10/_._" + ] + }, + "System.Runtime.Handles/4.0.1": { + "sha512": "nCJvEKguXEvk2ymk1gqj625vVnlK3/xdGzx0vOKicQkoquaTBJTP13AIYkocSUwHCLNBwUbXTqTWGDxBTWpt7g==", + "type": "package", + "path": "System.Runtime.Handles/4.0.1", + "files": [ + "System.Runtime.Handles.4.0.1.nupkg.sha512", + "System.Runtime.Handles.nuspec", + "ThirdPartyNotices.txt", + "dotnet_library_license.txt", + "lib/MonoAndroid10/_._", + "lib/MonoTouch10/_._", + "lib/net46/_._", + "lib/xamarinios10/_._", + "lib/xamarinmac20/_._", + "lib/xamarintvos10/_._", + "lib/xamarinwatchos10/_._", + "ref/MonoAndroid10/_._", + "ref/MonoTouch10/_._", + "ref/net46/_._", + "ref/netstandard1.3/System.Runtime.Handles.dll", + "ref/netstandard1.3/System.Runtime.Handles.xml", + "ref/netstandard1.3/de/System.Runtime.Handles.xml", + "ref/netstandard1.3/es/System.Runtime.Handles.xml", + "ref/netstandard1.3/fr/System.Runtime.Handles.xml", + "ref/netstandard1.3/it/System.Runtime.Handles.xml", + "ref/netstandard1.3/ja/System.Runtime.Handles.xml", + "ref/netstandard1.3/ko/System.Runtime.Handles.xml", + "ref/netstandard1.3/ru/System.Runtime.Handles.xml", + "ref/netstandard1.3/zh-hans/System.Runtime.Handles.xml", + "ref/netstandard1.3/zh-hant/System.Runtime.Handles.xml", + "ref/xamarinios10/_._", + "ref/xamarinmac20/_._", + "ref/xamarintvos10/_._", + "ref/xamarinwatchos10/_._" + ] + }, + "System.Runtime.InteropServices/4.1.0": { + "sha512": "16eu3kjHS633yYdkjwShDHZLRNMKVi/s0bY8ODiqJ2RfMhDMAwxZaUaWVnZ2P71kr/or+X9o/xFWtNqz8ivieQ==", + "type": "package", + "path": "System.Runtime.InteropServices/4.1.0", + "files": [ + "System.Runtime.InteropServices.4.1.0.nupkg.sha512", + "System.Runtime.InteropServices.nuspec", + "ThirdPartyNotices.txt", + "dotnet_library_license.txt", + "lib/MonoAndroid10/_._", + "lib/MonoTouch10/_._", + "lib/net45/_._", + "lib/net462/System.Runtime.InteropServices.dll", + "lib/portable-net45+win8+wpa81/_._", + "lib/win8/_._", + "lib/wpa81/_._", + "lib/xamarinios10/_._", + "lib/xamarinmac20/_._", + "lib/xamarintvos10/_._", + "lib/xamarinwatchos10/_._", + "ref/MonoAndroid10/_._", + "ref/MonoTouch10/_._", + "ref/net45/_._", + "ref/net462/System.Runtime.InteropServices.dll", + "ref/netcore50/System.Runtime.InteropServices.dll", + "ref/netcore50/System.Runtime.InteropServices.xml", + "ref/netcore50/de/System.Runtime.InteropServices.xml", + "ref/netcore50/es/System.Runtime.InteropServices.xml", + "ref/netcore50/fr/System.Runtime.InteropServices.xml", + "ref/netcore50/it/System.Runtime.InteropServices.xml", + "ref/netcore50/ja/System.Runtime.InteropServices.xml", + "ref/netcore50/ko/System.Runtime.InteropServices.xml", + "ref/netcore50/ru/System.Runtime.InteropServices.xml", + "ref/netcore50/zh-hans/System.Runtime.InteropServices.xml", + "ref/netcore50/zh-hant/System.Runtime.InteropServices.xml", + "ref/netstandard1.1/System.Runtime.InteropServices.dll", + "ref/netstandard1.1/System.Runtime.InteropServices.xml", + "ref/netstandard1.1/de/System.Runtime.InteropServices.xml", + "ref/netstandard1.1/es/System.Runtime.InteropServices.xml", + "ref/netstandard1.1/fr/System.Runtime.InteropServices.xml", + "ref/netstandard1.1/it/System.Runtime.InteropServices.xml", + "ref/netstandard1.1/ja/System.Runtime.InteropServices.xml", + "ref/netstandard1.1/ko/System.Runtime.InteropServices.xml", + "ref/netstandard1.1/ru/System.Runtime.InteropServices.xml", + "ref/netstandard1.1/zh-hans/System.Runtime.InteropServices.xml", + "ref/netstandard1.1/zh-hant/System.Runtime.InteropServices.xml", + "ref/netstandard1.2/System.Runtime.InteropServices.dll", + "ref/netstandard1.2/System.Runtime.InteropServices.xml", + "ref/netstandard1.2/de/System.Runtime.InteropServices.xml", + "ref/netstandard1.2/es/System.Runtime.InteropServices.xml", + "ref/netstandard1.2/fr/System.Runtime.InteropServices.xml", + "ref/netstandard1.2/it/System.Runtime.InteropServices.xml", + "ref/netstandard1.2/ja/System.Runtime.InteropServices.xml", + "ref/netstandard1.2/ko/System.Runtime.InteropServices.xml", + "ref/netstandard1.2/ru/System.Runtime.InteropServices.xml", + "ref/netstandard1.2/zh-hans/System.Runtime.InteropServices.xml", + "ref/netstandard1.2/zh-hant/System.Runtime.InteropServices.xml", + "ref/netstandard1.3/System.Runtime.InteropServices.dll", + "ref/netstandard1.3/System.Runtime.InteropServices.xml", + "ref/netstandard1.3/de/System.Runtime.InteropServices.xml", + "ref/netstandard1.3/es/System.Runtime.InteropServices.xml", + "ref/netstandard1.3/fr/System.Runtime.InteropServices.xml", + "ref/netstandard1.3/it/System.Runtime.InteropServices.xml", + "ref/netstandard1.3/ja/System.Runtime.InteropServices.xml", + "ref/netstandard1.3/ko/System.Runtime.InteropServices.xml", + "ref/netstandard1.3/ru/System.Runtime.InteropServices.xml", + "ref/netstandard1.3/zh-hans/System.Runtime.InteropServices.xml", + "ref/netstandard1.3/zh-hant/System.Runtime.InteropServices.xml", + "ref/netstandard1.5/System.Runtime.InteropServices.dll", + "ref/netstandard1.5/System.Runtime.InteropServices.xml", + "ref/netstandard1.5/de/System.Runtime.InteropServices.xml", + "ref/netstandard1.5/es/System.Runtime.InteropServices.xml", + "ref/netstandard1.5/fr/System.Runtime.InteropServices.xml", + "ref/netstandard1.5/it/System.Runtime.InteropServices.xml", + "ref/netstandard1.5/ja/System.Runtime.InteropServices.xml", + "ref/netstandard1.5/ko/System.Runtime.InteropServices.xml", + "ref/netstandard1.5/ru/System.Runtime.InteropServices.xml", + "ref/netstandard1.5/zh-hans/System.Runtime.InteropServices.xml", + "ref/netstandard1.5/zh-hant/System.Runtime.InteropServices.xml", + "ref/portable-net45+win8+wpa81/_._", + "ref/win8/_._", + "ref/wpa81/_._", + "ref/xamarinios10/_._", + "ref/xamarinmac20/_._", + "ref/xamarintvos10/_._", + "ref/xamarinwatchos10/_._" + ] + }, + "System.Runtime.InteropServices.RuntimeInformation/4.0.0": { + "sha512": "hWPhJxc453RCa8Z29O91EmfGeZIHX1ZH2A8L6lYQVSaKzku2DfArSfMEb1/MYYzPQRJZeu0c9dmYeJKxW5Fgng==", + "type": "package", + "path": "System.Runtime.InteropServices.RuntimeInformation/4.0.0", + "files": [ + "System.Runtime.InteropServices.RuntimeInformation.4.0.0.nupkg.sha512", + "System.Runtime.InteropServices.RuntimeInformation.nuspec", + "ThirdPartyNotices.txt", + "dotnet_library_license.txt", + "lib/MonoAndroid10/_._", + "lib/MonoTouch10/_._", + "lib/net45/System.Runtime.InteropServices.RuntimeInformation.dll", + "lib/win8/System.Runtime.InteropServices.RuntimeInformation.dll", + "lib/wpa81/System.Runtime.InteropServices.RuntimeInformation.dll", + "lib/xamarinios10/_._", + "lib/xamarinmac20/_._", + "lib/xamarintvos10/_._", + "lib/xamarinwatchos10/_._", + "ref/MonoAndroid10/_._", + "ref/MonoTouch10/_._", + "ref/netstandard1.1/System.Runtime.InteropServices.RuntimeInformation.dll", + "ref/xamarinios10/_._", + "ref/xamarinmac20/_._", + "ref/xamarintvos10/_._", + "ref/xamarinwatchos10/_._", + "runtimes/aot/lib/netcore50/System.Runtime.InteropServices.RuntimeInformation.dll", + "runtimes/unix/lib/netstandard1.1/System.Runtime.InteropServices.RuntimeInformation.dll", + "runtimes/win/lib/net45/System.Runtime.InteropServices.RuntimeInformation.dll", + "runtimes/win/lib/netcore50/System.Runtime.InteropServices.RuntimeInformation.dll", + "runtimes/win/lib/netstandard1.1/System.Runtime.InteropServices.RuntimeInformation.dll" + ] + }, + "System.Runtime.Numerics/4.0.1": { + "sha512": "+XbKFuzdmLP3d1o9pdHu2nxjNr2OEPqGzKeegPLCUMM71a0t50A/rOcIRmGs9wR7a8KuHX6hYs/7/TymIGLNqg==", + "type": "package", + "path": "System.Runtime.Numerics/4.0.1", + "files": [ + "System.Runtime.Numerics.4.0.1.nupkg.sha512", + "System.Runtime.Numerics.nuspec", + "ThirdPartyNotices.txt", + "dotnet_library_license.txt", + "lib/MonoAndroid10/_._", + "lib/MonoTouch10/_._", + "lib/net45/_._", + "lib/netcore50/System.Runtime.Numerics.dll", + "lib/netstandard1.3/System.Runtime.Numerics.dll", + "lib/portable-net45+win8+wpa81/_._", + "lib/win8/_._", + "lib/wpa81/_._", + "lib/xamarinios10/_._", + "lib/xamarinmac20/_._", + "lib/xamarintvos10/_._", + "lib/xamarinwatchos10/_._", + "ref/MonoAndroid10/_._", + "ref/MonoTouch10/_._", + "ref/net45/_._", + "ref/netcore50/System.Runtime.Numerics.dll", + "ref/netcore50/System.Runtime.Numerics.xml", + "ref/netcore50/de/System.Runtime.Numerics.xml", + "ref/netcore50/es/System.Runtime.Numerics.xml", + "ref/netcore50/fr/System.Runtime.Numerics.xml", + "ref/netcore50/it/System.Runtime.Numerics.xml", + "ref/netcore50/ja/System.Runtime.Numerics.xml", + "ref/netcore50/ko/System.Runtime.Numerics.xml", + "ref/netcore50/ru/System.Runtime.Numerics.xml", + "ref/netcore50/zh-hans/System.Runtime.Numerics.xml", + "ref/netcore50/zh-hant/System.Runtime.Numerics.xml", + "ref/netstandard1.1/System.Runtime.Numerics.dll", + "ref/netstandard1.1/System.Runtime.Numerics.xml", + "ref/netstandard1.1/de/System.Runtime.Numerics.xml", + "ref/netstandard1.1/es/System.Runtime.Numerics.xml", + "ref/netstandard1.1/fr/System.Runtime.Numerics.xml", + "ref/netstandard1.1/it/System.Runtime.Numerics.xml", + "ref/netstandard1.1/ja/System.Runtime.Numerics.xml", + "ref/netstandard1.1/ko/System.Runtime.Numerics.xml", + "ref/netstandard1.1/ru/System.Runtime.Numerics.xml", + "ref/netstandard1.1/zh-hans/System.Runtime.Numerics.xml", + "ref/netstandard1.1/zh-hant/System.Runtime.Numerics.xml", + "ref/portable-net45+win8+wpa81/_._", + "ref/win8/_._", + "ref/wpa81/_._", + "ref/xamarinios10/_._", + "ref/xamarinmac20/_._", + "ref/xamarintvos10/_._", + "ref/xamarinwatchos10/_._" + ] + }, + "System.Security.Cryptography.Algorithms/4.2.0": { + "sha512": "8JQFxbLVdrtIOKMDN38Fn0GWnqYZw/oMlwOUG/qz1jqChvyZlnUmu+0s7wLx7JYua/nAXoESpHA3iw11QFWhXg==", + "type": "package", + "path": "System.Security.Cryptography.Algorithms/4.2.0", + "files": [ + "System.Security.Cryptography.Algorithms.4.2.0.nupkg.sha512", + "System.Security.Cryptography.Algorithms.nuspec", + "ThirdPartyNotices.txt", + "dotnet_library_license.txt", + "lib/MonoAndroid10/_._", + "lib/MonoTouch10/_._", + "lib/net46/System.Security.Cryptography.Algorithms.dll", + "lib/net461/System.Security.Cryptography.Algorithms.dll", + "lib/net463/System.Security.Cryptography.Algorithms.dll", + "lib/xamarinios10/_._", + "lib/xamarinmac20/_._", + "lib/xamarintvos10/_._", + "lib/xamarinwatchos10/_._", + "ref/MonoAndroid10/_._", + "ref/MonoTouch10/_._", + "ref/net46/System.Security.Cryptography.Algorithms.dll", + "ref/net461/System.Security.Cryptography.Algorithms.dll", + "ref/net463/System.Security.Cryptography.Algorithms.dll", + "ref/netstandard1.3/System.Security.Cryptography.Algorithms.dll", + "ref/netstandard1.4/System.Security.Cryptography.Algorithms.dll", + "ref/netstandard1.6/System.Security.Cryptography.Algorithms.dll", + "ref/xamarinios10/_._", + "ref/xamarinmac20/_._", + "ref/xamarintvos10/_._", + "ref/xamarinwatchos10/_._", + "runtimes/unix/lib/netstandard1.6/System.Security.Cryptography.Algorithms.dll", + "runtimes/win/lib/net46/System.Security.Cryptography.Algorithms.dll", + "runtimes/win/lib/net461/System.Security.Cryptography.Algorithms.dll", + "runtimes/win/lib/net463/System.Security.Cryptography.Algorithms.dll", + "runtimes/win/lib/netcore50/System.Security.Cryptography.Algorithms.dll", + "runtimes/win/lib/netstandard1.6/System.Security.Cryptography.Algorithms.dll" + ] + }, + "System.Security.Cryptography.Cng/4.2.0": { + "sha512": "cUJ2h+ZvONDe28Szw3st5dOHdjndhJzQ2WObDEXAWRPEQBtVItVoxbXM/OEsTthl3cNn2dk2k0I3y45igCQcLw==", + "type": "package", + "path": "System.Security.Cryptography.Cng/4.2.0", + "files": [ + "System.Security.Cryptography.Cng.4.2.0.nupkg.sha512", + "System.Security.Cryptography.Cng.nuspec", + "ThirdPartyNotices.txt", + "dotnet_library_license.txt", + "lib/net46/System.Security.Cryptography.Cng.dll", + "lib/net461/System.Security.Cryptography.Cng.dll", + "lib/net463/System.Security.Cryptography.Cng.dll", + "ref/net46/System.Security.Cryptography.Cng.dll", + "ref/net461/System.Security.Cryptography.Cng.dll", + "ref/net463/System.Security.Cryptography.Cng.dll", + "ref/netstandard1.3/System.Security.Cryptography.Cng.dll", + "ref/netstandard1.4/System.Security.Cryptography.Cng.dll", + "ref/netstandard1.6/System.Security.Cryptography.Cng.dll", + "runtimes/unix/lib/netstandard1.6/System.Security.Cryptography.Cng.dll", + "runtimes/win/lib/net46/System.Security.Cryptography.Cng.dll", + "runtimes/win/lib/net461/System.Security.Cryptography.Cng.dll", + "runtimes/win/lib/net463/System.Security.Cryptography.Cng.dll", + "runtimes/win/lib/netstandard1.4/System.Security.Cryptography.Cng.dll", + "runtimes/win/lib/netstandard1.6/System.Security.Cryptography.Cng.dll" + ] + }, + "System.Security.Cryptography.Csp/4.0.0": { + "sha512": "/i1Usuo4PgAqgbPNC0NjbO3jPW//BoBlTpcWFD1EHVbidH21y4c1ap5bbEMSGAXjAShhMH4abi/K8fILrnu4BQ==", + "type": "package", + "path": "System.Security.Cryptography.Csp/4.0.0", + "files": [ + "System.Security.Cryptography.Csp.4.0.0.nupkg.sha512", + "System.Security.Cryptography.Csp.nuspec", + "ThirdPartyNotices.txt", + "dotnet_library_license.txt", + "lib/MonoAndroid10/_._", + "lib/MonoTouch10/_._", + "lib/net46/System.Security.Cryptography.Csp.dll", + "lib/xamarinios10/_._", + "lib/xamarinmac20/_._", + "lib/xamarintvos10/_._", + "lib/xamarinwatchos10/_._", + "ref/MonoAndroid10/_._", + "ref/MonoTouch10/_._", + "ref/net46/System.Security.Cryptography.Csp.dll", + "ref/netstandard1.3/System.Security.Cryptography.Csp.dll", + "ref/xamarinios10/_._", + "ref/xamarinmac20/_._", + "ref/xamarintvos10/_._", + "ref/xamarinwatchos10/_._", + "runtimes/unix/lib/netstandard1.3/System.Security.Cryptography.Csp.dll", + "runtimes/win/lib/net46/System.Security.Cryptography.Csp.dll", + "runtimes/win/lib/netcore50/_._", + "runtimes/win/lib/netstandard1.3/System.Security.Cryptography.Csp.dll" + ] + }, + "System.Security.Cryptography.Encoding/4.0.0": { + "sha512": "FbKgE5MbxSQMPcSVRgwM6bXN3GtyAh04NkV8E5zKCBE26X0vYW0UtTa2FIgkH33WVqBVxRgxljlVYumWtU+HcQ==", + "type": "package", + "path": "System.Security.Cryptography.Encoding/4.0.0", + "files": [ + "System.Security.Cryptography.Encoding.4.0.0.nupkg.sha512", + "System.Security.Cryptography.Encoding.nuspec", + "ThirdPartyNotices.txt", + "dotnet_library_license.txt", + "lib/MonoAndroid10/_._", + "lib/MonoTouch10/_._", + "lib/net46/System.Security.Cryptography.Encoding.dll", + "lib/xamarinios10/_._", + "lib/xamarinmac20/_._", + "lib/xamarintvos10/_._", + "lib/xamarinwatchos10/_._", + "ref/MonoAndroid10/_._", + "ref/MonoTouch10/_._", + "ref/net46/System.Security.Cryptography.Encoding.dll", + "ref/netstandard1.3/System.Security.Cryptography.Encoding.dll", + "ref/netstandard1.3/System.Security.Cryptography.Encoding.xml", + "ref/netstandard1.3/de/System.Security.Cryptography.Encoding.xml", + "ref/netstandard1.3/es/System.Security.Cryptography.Encoding.xml", + "ref/netstandard1.3/fr/System.Security.Cryptography.Encoding.xml", + "ref/netstandard1.3/it/System.Security.Cryptography.Encoding.xml", + "ref/netstandard1.3/ja/System.Security.Cryptography.Encoding.xml", + "ref/netstandard1.3/ko/System.Security.Cryptography.Encoding.xml", + "ref/netstandard1.3/ru/System.Security.Cryptography.Encoding.xml", + "ref/netstandard1.3/zh-hans/System.Security.Cryptography.Encoding.xml", + "ref/netstandard1.3/zh-hant/System.Security.Cryptography.Encoding.xml", + "ref/xamarinios10/_._", + "ref/xamarinmac20/_._", + "ref/xamarintvos10/_._", + "ref/xamarinwatchos10/_._", + "runtimes/unix/lib/netstandard1.3/System.Security.Cryptography.Encoding.dll", + "runtimes/win/lib/net46/System.Security.Cryptography.Encoding.dll", + "runtimes/win/lib/netstandard1.3/System.Security.Cryptography.Encoding.dll" + ] + }, + "System.Security.Cryptography.OpenSsl/4.0.0": { + "sha512": "HUG/zNUJwEiLkoURDixzkzZdB5yGA5pQhDP93ArOpDPQMteURIGERRNzzoJlmTreLBWr5lkFSjjMSk8ySEpQMw==", + "type": "package", + "path": "System.Security.Cryptography.OpenSsl/4.0.0", + "files": [ + "System.Security.Cryptography.OpenSsl.4.0.0.nupkg.sha512", + "System.Security.Cryptography.OpenSsl.nuspec", + "ThirdPartyNotices.txt", + "dotnet_library_license.txt", + "lib/netstandard1.6/System.Security.Cryptography.OpenSsl.dll", + "ref/netstandard1.6/System.Security.Cryptography.OpenSsl.dll", + "runtimes/unix/lib/netstandard1.6/System.Security.Cryptography.OpenSsl.dll" + ] + }, + "System.Security.Cryptography.Primitives/4.0.0": { + "sha512": "Wkd7QryWYjkQclX0bngpntW5HSlMzeJU24UaLJQ7YTfI8ydAVAaU2J+HXLLABOVJlKTVvAeL0Aj39VeTe7L+oA==", + "type": "package", + "path": "System.Security.Cryptography.Primitives/4.0.0", + "files": [ + "System.Security.Cryptography.Primitives.4.0.0.nupkg.sha512", + "System.Security.Cryptography.Primitives.nuspec", + "ThirdPartyNotices.txt", + "dotnet_library_license.txt", + "lib/MonoAndroid10/_._", + "lib/MonoTouch10/_._", + "lib/net46/System.Security.Cryptography.Primitives.dll", + "lib/netstandard1.3/System.Security.Cryptography.Primitives.dll", + "lib/xamarinios10/_._", + "lib/xamarinmac20/_._", + "lib/xamarintvos10/_._", + "lib/xamarinwatchos10/_._", + "ref/MonoAndroid10/_._", + "ref/MonoTouch10/_._", + "ref/net46/System.Security.Cryptography.Primitives.dll", + "ref/netstandard1.3/System.Security.Cryptography.Primitives.dll", + "ref/xamarinios10/_._", + "ref/xamarinmac20/_._", + "ref/xamarintvos10/_._", + "ref/xamarinwatchos10/_._" + ] + }, + "System.Security.Cryptography.X509Certificates/4.1.0": { + "sha512": "4HEfsQIKAhA1+ApNn729Gi09zh+lYWwyIuViihoMDWp1vQnEkL2ct7mAbhBlLYm+x/L4Rr/pyGge1lIY635e0w==", + "type": "package", + "path": "System.Security.Cryptography.X509Certificates/4.1.0", + "files": [ + "System.Security.Cryptography.X509Certificates.4.1.0.nupkg.sha512", + "System.Security.Cryptography.X509Certificates.nuspec", + "ThirdPartyNotices.txt", + "dotnet_library_license.txt", + "lib/MonoAndroid10/_._", + "lib/MonoTouch10/_._", + "lib/net46/System.Security.Cryptography.X509Certificates.dll", + "lib/net461/System.Security.Cryptography.X509Certificates.dll", + "lib/xamarinios10/_._", + "lib/xamarinmac20/_._", + "lib/xamarintvos10/_._", + "lib/xamarinwatchos10/_._", + "ref/MonoAndroid10/_._", + "ref/MonoTouch10/_._", + "ref/net46/System.Security.Cryptography.X509Certificates.dll", + "ref/net461/System.Security.Cryptography.X509Certificates.dll", + "ref/netstandard1.3/System.Security.Cryptography.X509Certificates.dll", + "ref/netstandard1.3/System.Security.Cryptography.X509Certificates.xml", + "ref/netstandard1.3/de/System.Security.Cryptography.X509Certificates.xml", + "ref/netstandard1.3/es/System.Security.Cryptography.X509Certificates.xml", + "ref/netstandard1.3/fr/System.Security.Cryptography.X509Certificates.xml", + "ref/netstandard1.3/it/System.Security.Cryptography.X509Certificates.xml", + "ref/netstandard1.3/ja/System.Security.Cryptography.X509Certificates.xml", + "ref/netstandard1.3/ko/System.Security.Cryptography.X509Certificates.xml", + "ref/netstandard1.3/ru/System.Security.Cryptography.X509Certificates.xml", + "ref/netstandard1.3/zh-hans/System.Security.Cryptography.X509Certificates.xml", + "ref/netstandard1.3/zh-hant/System.Security.Cryptography.X509Certificates.xml", + "ref/netstandard1.4/System.Security.Cryptography.X509Certificates.dll", + "ref/netstandard1.4/System.Security.Cryptography.X509Certificates.xml", + "ref/netstandard1.4/de/System.Security.Cryptography.X509Certificates.xml", + "ref/netstandard1.4/es/System.Security.Cryptography.X509Certificates.xml", + "ref/netstandard1.4/fr/System.Security.Cryptography.X509Certificates.xml", + "ref/netstandard1.4/it/System.Security.Cryptography.X509Certificates.xml", + "ref/netstandard1.4/ja/System.Security.Cryptography.X509Certificates.xml", + "ref/netstandard1.4/ko/System.Security.Cryptography.X509Certificates.xml", + "ref/netstandard1.4/ru/System.Security.Cryptography.X509Certificates.xml", + "ref/netstandard1.4/zh-hans/System.Security.Cryptography.X509Certificates.xml", + "ref/netstandard1.4/zh-hant/System.Security.Cryptography.X509Certificates.xml", + "ref/xamarinios10/_._", + "ref/xamarinmac20/_._", + "ref/xamarintvos10/_._", + "ref/xamarinwatchos10/_._", + "runtimes/unix/lib/netstandard1.6/System.Security.Cryptography.X509Certificates.dll", + "runtimes/win/lib/net46/System.Security.Cryptography.X509Certificates.dll", + "runtimes/win/lib/net461/System.Security.Cryptography.X509Certificates.dll", + "runtimes/win/lib/netcore50/System.Security.Cryptography.X509Certificates.dll", + "runtimes/win/lib/netstandard1.6/System.Security.Cryptography.X509Certificates.dll" + ] + }, + "System.Text.Encoding/4.0.11": { + "sha512": "U3gGeMlDZXxCEiY4DwVLSacg+DFWCvoiX+JThA/rvw37Sqrku7sEFeVBBBMBnfB6FeZHsyDx85HlKL19x0HtZA==", + "type": "package", + "path": "System.Text.Encoding/4.0.11", + "files": [ + "System.Text.Encoding.4.0.11.nupkg.sha512", + "System.Text.Encoding.nuspec", + "ThirdPartyNotices.txt", + "dotnet_library_license.txt", + "lib/MonoAndroid10/_._", + "lib/MonoTouch10/_._", + "lib/net45/_._", + "lib/portable-net45+win8+wp8+wpa81/_._", + "lib/win8/_._", + "lib/wp80/_._", + "lib/wpa81/_._", + "lib/xamarinios10/_._", + "lib/xamarinmac20/_._", + "lib/xamarintvos10/_._", + "lib/xamarinwatchos10/_._", + "ref/MonoAndroid10/_._", + "ref/MonoTouch10/_._", + "ref/net45/_._", + "ref/netcore50/System.Text.Encoding.dll", + "ref/netcore50/System.Text.Encoding.xml", + "ref/netcore50/de/System.Text.Encoding.xml", + "ref/netcore50/es/System.Text.Encoding.xml", + "ref/netcore50/fr/System.Text.Encoding.xml", + "ref/netcore50/it/System.Text.Encoding.xml", + "ref/netcore50/ja/System.Text.Encoding.xml", + "ref/netcore50/ko/System.Text.Encoding.xml", + "ref/netcore50/ru/System.Text.Encoding.xml", + "ref/netcore50/zh-hans/System.Text.Encoding.xml", + "ref/netcore50/zh-hant/System.Text.Encoding.xml", + "ref/netstandard1.0/System.Text.Encoding.dll", + "ref/netstandard1.0/System.Text.Encoding.xml", + "ref/netstandard1.0/de/System.Text.Encoding.xml", + "ref/netstandard1.0/es/System.Text.Encoding.xml", + "ref/netstandard1.0/fr/System.Text.Encoding.xml", + "ref/netstandard1.0/it/System.Text.Encoding.xml", + "ref/netstandard1.0/ja/System.Text.Encoding.xml", + "ref/netstandard1.0/ko/System.Text.Encoding.xml", + "ref/netstandard1.0/ru/System.Text.Encoding.xml", + "ref/netstandard1.0/zh-hans/System.Text.Encoding.xml", + "ref/netstandard1.0/zh-hant/System.Text.Encoding.xml", + "ref/netstandard1.3/System.Text.Encoding.dll", + "ref/netstandard1.3/System.Text.Encoding.xml", + "ref/netstandard1.3/de/System.Text.Encoding.xml", + "ref/netstandard1.3/es/System.Text.Encoding.xml", + "ref/netstandard1.3/fr/System.Text.Encoding.xml", + "ref/netstandard1.3/it/System.Text.Encoding.xml", + "ref/netstandard1.3/ja/System.Text.Encoding.xml", + "ref/netstandard1.3/ko/System.Text.Encoding.xml", + "ref/netstandard1.3/ru/System.Text.Encoding.xml", + "ref/netstandard1.3/zh-hans/System.Text.Encoding.xml", + "ref/netstandard1.3/zh-hant/System.Text.Encoding.xml", + "ref/portable-net45+win8+wp8+wpa81/_._", + "ref/win8/_._", + "ref/wp80/_._", + "ref/wpa81/_._", + "ref/xamarinios10/_._", + "ref/xamarinmac20/_._", + "ref/xamarintvos10/_._", + "ref/xamarinwatchos10/_._" + ] + }, + "System.Text.Encoding.Extensions/4.0.11": { + "sha512": "jtbiTDtvfLYgXn8PTfWI+SiBs51rrmO4AAckx4KR6vFK9Wzf6tI8kcRdsYQNwriUeQ1+CtQbM1W4cMbLXnj/OQ==", + "type": "package", + "path": "System.Text.Encoding.Extensions/4.0.11", + "files": [ + "System.Text.Encoding.Extensions.4.0.11.nupkg.sha512", + "System.Text.Encoding.Extensions.nuspec", + "ThirdPartyNotices.txt", + "dotnet_library_license.txt", + "lib/MonoAndroid10/_._", + "lib/MonoTouch10/_._", + "lib/net45/_._", + "lib/portable-net45+win8+wp8+wpa81/_._", + "lib/win8/_._", + "lib/wp80/_._", + "lib/wpa81/_._", + "lib/xamarinios10/_._", + "lib/xamarinmac20/_._", + "lib/xamarintvos10/_._", + "lib/xamarinwatchos10/_._", + "ref/MonoAndroid10/_._", + "ref/MonoTouch10/_._", + "ref/net45/_._", + "ref/netcore50/System.Text.Encoding.Extensions.dll", + "ref/netcore50/System.Text.Encoding.Extensions.xml", + "ref/netcore50/de/System.Text.Encoding.Extensions.xml", + "ref/netcore50/es/System.Text.Encoding.Extensions.xml", + "ref/netcore50/fr/System.Text.Encoding.Extensions.xml", + "ref/netcore50/it/System.Text.Encoding.Extensions.xml", + "ref/netcore50/ja/System.Text.Encoding.Extensions.xml", + "ref/netcore50/ko/System.Text.Encoding.Extensions.xml", + "ref/netcore50/ru/System.Text.Encoding.Extensions.xml", + "ref/netcore50/zh-hans/System.Text.Encoding.Extensions.xml", + "ref/netcore50/zh-hant/System.Text.Encoding.Extensions.xml", + "ref/netstandard1.0/System.Text.Encoding.Extensions.dll", + "ref/netstandard1.0/System.Text.Encoding.Extensions.xml", + "ref/netstandard1.0/de/System.Text.Encoding.Extensions.xml", + "ref/netstandard1.0/es/System.Text.Encoding.Extensions.xml", + "ref/netstandard1.0/fr/System.Text.Encoding.Extensions.xml", + "ref/netstandard1.0/it/System.Text.Encoding.Extensions.xml", + "ref/netstandard1.0/ja/System.Text.Encoding.Extensions.xml", + "ref/netstandard1.0/ko/System.Text.Encoding.Extensions.xml", + "ref/netstandard1.0/ru/System.Text.Encoding.Extensions.xml", + "ref/netstandard1.0/zh-hans/System.Text.Encoding.Extensions.xml", + "ref/netstandard1.0/zh-hant/System.Text.Encoding.Extensions.xml", + "ref/netstandard1.3/System.Text.Encoding.Extensions.dll", + "ref/netstandard1.3/System.Text.Encoding.Extensions.xml", + "ref/netstandard1.3/de/System.Text.Encoding.Extensions.xml", + "ref/netstandard1.3/es/System.Text.Encoding.Extensions.xml", + "ref/netstandard1.3/fr/System.Text.Encoding.Extensions.xml", + "ref/netstandard1.3/it/System.Text.Encoding.Extensions.xml", + "ref/netstandard1.3/ja/System.Text.Encoding.Extensions.xml", + "ref/netstandard1.3/ko/System.Text.Encoding.Extensions.xml", + "ref/netstandard1.3/ru/System.Text.Encoding.Extensions.xml", + "ref/netstandard1.3/zh-hans/System.Text.Encoding.Extensions.xml", + "ref/netstandard1.3/zh-hant/System.Text.Encoding.Extensions.xml", + "ref/portable-net45+win8+wp8+wpa81/_._", + "ref/win8/_._", + "ref/wp80/_._", + "ref/wpa81/_._", + "ref/xamarinios10/_._", + "ref/xamarinmac20/_._", + "ref/xamarintvos10/_._", + "ref/xamarinwatchos10/_._" + ] + }, + "System.Text.RegularExpressions/4.1.0": { + "sha512": "i88YCXpRTjCnoSQZtdlHkAOx4KNNik4hMy83n0+Ftlb7jvV6ZiZWMpnEZHhjBp6hQVh8gWd/iKNPzlPF7iyA2g==", + "type": "package", + "path": "System.Text.RegularExpressions/4.1.0", + "files": [ + "System.Text.RegularExpressions.4.1.0.nupkg.sha512", + "System.Text.RegularExpressions.nuspec", + "ThirdPartyNotices.txt", + "dotnet_library_license.txt", + "lib/MonoAndroid10/_._", + "lib/MonoTouch10/_._", + "lib/net45/_._", + "lib/net463/System.Text.RegularExpressions.dll", + "lib/netcore50/System.Text.RegularExpressions.dll", + "lib/netstandard1.6/System.Text.RegularExpressions.dll", + "lib/portable-net45+win8+wp8+wpa81/_._", + "lib/win8/_._", + "lib/wp80/_._", + "lib/wpa81/_._", + "lib/xamarinios10/_._", + "lib/xamarinmac20/_._", + "lib/xamarintvos10/_._", + "lib/xamarinwatchos10/_._", + "ref/MonoAndroid10/_._", + "ref/MonoTouch10/_._", + "ref/net45/_._", + "ref/net463/System.Text.RegularExpressions.dll", + "ref/netcore50/System.Text.RegularExpressions.dll", + "ref/netcore50/System.Text.RegularExpressions.xml", + "ref/netcore50/de/System.Text.RegularExpressions.xml", + "ref/netcore50/es/System.Text.RegularExpressions.xml", + "ref/netcore50/fr/System.Text.RegularExpressions.xml", + "ref/netcore50/it/System.Text.RegularExpressions.xml", + "ref/netcore50/ja/System.Text.RegularExpressions.xml", + "ref/netcore50/ko/System.Text.RegularExpressions.xml", + "ref/netcore50/ru/System.Text.RegularExpressions.xml", + "ref/netcore50/zh-hans/System.Text.RegularExpressions.xml", + "ref/netcore50/zh-hant/System.Text.RegularExpressions.xml", + "ref/netstandard1.0/System.Text.RegularExpressions.dll", + "ref/netstandard1.0/System.Text.RegularExpressions.xml", + "ref/netstandard1.0/de/System.Text.RegularExpressions.xml", + "ref/netstandard1.0/es/System.Text.RegularExpressions.xml", + "ref/netstandard1.0/fr/System.Text.RegularExpressions.xml", + "ref/netstandard1.0/it/System.Text.RegularExpressions.xml", + "ref/netstandard1.0/ja/System.Text.RegularExpressions.xml", + "ref/netstandard1.0/ko/System.Text.RegularExpressions.xml", + "ref/netstandard1.0/ru/System.Text.RegularExpressions.xml", + "ref/netstandard1.0/zh-hans/System.Text.RegularExpressions.xml", + "ref/netstandard1.0/zh-hant/System.Text.RegularExpressions.xml", + "ref/netstandard1.3/System.Text.RegularExpressions.dll", + "ref/netstandard1.3/System.Text.RegularExpressions.xml", + "ref/netstandard1.3/de/System.Text.RegularExpressions.xml", + "ref/netstandard1.3/es/System.Text.RegularExpressions.xml", + "ref/netstandard1.3/fr/System.Text.RegularExpressions.xml", + "ref/netstandard1.3/it/System.Text.RegularExpressions.xml", + "ref/netstandard1.3/ja/System.Text.RegularExpressions.xml", + "ref/netstandard1.3/ko/System.Text.RegularExpressions.xml", + "ref/netstandard1.3/ru/System.Text.RegularExpressions.xml", + "ref/netstandard1.3/zh-hans/System.Text.RegularExpressions.xml", + "ref/netstandard1.3/zh-hant/System.Text.RegularExpressions.xml", + "ref/netstandard1.6/System.Text.RegularExpressions.dll", + "ref/netstandard1.6/System.Text.RegularExpressions.xml", + "ref/netstandard1.6/de/System.Text.RegularExpressions.xml", + "ref/netstandard1.6/es/System.Text.RegularExpressions.xml", + "ref/netstandard1.6/fr/System.Text.RegularExpressions.xml", + "ref/netstandard1.6/it/System.Text.RegularExpressions.xml", + "ref/netstandard1.6/ja/System.Text.RegularExpressions.xml", + "ref/netstandard1.6/ko/System.Text.RegularExpressions.xml", + "ref/netstandard1.6/ru/System.Text.RegularExpressions.xml", + "ref/netstandard1.6/zh-hans/System.Text.RegularExpressions.xml", + "ref/netstandard1.6/zh-hant/System.Text.RegularExpressions.xml", + "ref/portable-net45+win8+wp8+wpa81/_._", + "ref/win8/_._", + "ref/wp80/_._", + "ref/wpa81/_._", + "ref/xamarinios10/_._", + "ref/xamarinmac20/_._", + "ref/xamarintvos10/_._", + "ref/xamarinwatchos10/_._" + ] + }, + "System.Threading/4.0.11": { + "sha512": "N+3xqIcg3VDKyjwwCGaZ9HawG9aC6cSDI+s7ROma310GQo8vilFZa86hqKppwTHleR/G0sfOzhvgnUxWCR/DrQ==", + "type": "package", + "path": "System.Threading/4.0.11", + "files": [ + "System.Threading.4.0.11.nupkg.sha512", + "System.Threading.nuspec", + "ThirdPartyNotices.txt", + "dotnet_library_license.txt", + "lib/MonoAndroid10/_._", + "lib/MonoTouch10/_._", + "lib/net45/_._", + "lib/netcore50/System.Threading.dll", + "lib/netstandard1.3/System.Threading.dll", + "lib/portable-net45+win8+wp8+wpa81/_._", + "lib/win8/_._", + "lib/wp80/_._", + "lib/wpa81/_._", + "lib/xamarinios10/_._", + "lib/xamarinmac20/_._", + "lib/xamarintvos10/_._", + "lib/xamarinwatchos10/_._", + "ref/MonoAndroid10/_._", + "ref/MonoTouch10/_._", + "ref/net45/_._", + "ref/netcore50/System.Threading.dll", + "ref/netcore50/System.Threading.xml", + "ref/netcore50/de/System.Threading.xml", + "ref/netcore50/es/System.Threading.xml", + "ref/netcore50/fr/System.Threading.xml", + "ref/netcore50/it/System.Threading.xml", + "ref/netcore50/ja/System.Threading.xml", + "ref/netcore50/ko/System.Threading.xml", + "ref/netcore50/ru/System.Threading.xml", + "ref/netcore50/zh-hans/System.Threading.xml", + "ref/netcore50/zh-hant/System.Threading.xml", + "ref/netstandard1.0/System.Threading.dll", + "ref/netstandard1.0/System.Threading.xml", + "ref/netstandard1.0/de/System.Threading.xml", + "ref/netstandard1.0/es/System.Threading.xml", + "ref/netstandard1.0/fr/System.Threading.xml", + "ref/netstandard1.0/it/System.Threading.xml", + "ref/netstandard1.0/ja/System.Threading.xml", + "ref/netstandard1.0/ko/System.Threading.xml", + "ref/netstandard1.0/ru/System.Threading.xml", + "ref/netstandard1.0/zh-hans/System.Threading.xml", + "ref/netstandard1.0/zh-hant/System.Threading.xml", + "ref/netstandard1.3/System.Threading.dll", + "ref/netstandard1.3/System.Threading.xml", + "ref/netstandard1.3/de/System.Threading.xml", + "ref/netstandard1.3/es/System.Threading.xml", + "ref/netstandard1.3/fr/System.Threading.xml", + "ref/netstandard1.3/it/System.Threading.xml", + "ref/netstandard1.3/ja/System.Threading.xml", + "ref/netstandard1.3/ko/System.Threading.xml", + "ref/netstandard1.3/ru/System.Threading.xml", + "ref/netstandard1.3/zh-hans/System.Threading.xml", + "ref/netstandard1.3/zh-hant/System.Threading.xml", + "ref/portable-net45+win8+wp8+wpa81/_._", + "ref/win8/_._", + "ref/wp80/_._", + "ref/wpa81/_._", + "ref/xamarinios10/_._", + "ref/xamarinmac20/_._", + "ref/xamarintvos10/_._", + "ref/xamarinwatchos10/_._", + "runtimes/aot/lib/netcore50/System.Threading.dll" + ] + }, + "System.Threading.Tasks/4.0.11": { + "sha512": "k1S4Gc6IGwtHGT8188RSeGaX86Qw/wnrgNLshJvsdNUOPP9etMmo8S07c+UlOAx4K/xLuN9ivA1bD0LVurtIxQ==", + "type": "package", + "path": "System.Threading.Tasks/4.0.11", + "files": [ + "System.Threading.Tasks.4.0.11.nupkg.sha512", + "System.Threading.Tasks.nuspec", + "ThirdPartyNotices.txt", + "dotnet_library_license.txt", + "lib/MonoAndroid10/_._", + "lib/MonoTouch10/_._", + "lib/net45/_._", + "lib/portable-net45+win8+wp8+wpa81/_._", + "lib/win8/_._", + "lib/wp80/_._", + "lib/wpa81/_._", + "lib/xamarinios10/_._", + "lib/xamarinmac20/_._", + "lib/xamarintvos10/_._", + "lib/xamarinwatchos10/_._", + "ref/MonoAndroid10/_._", + "ref/MonoTouch10/_._", + "ref/net45/_._", + "ref/netcore50/System.Threading.Tasks.dll", + "ref/netcore50/System.Threading.Tasks.xml", + "ref/netcore50/de/System.Threading.Tasks.xml", + "ref/netcore50/es/System.Threading.Tasks.xml", + "ref/netcore50/fr/System.Threading.Tasks.xml", + "ref/netcore50/it/System.Threading.Tasks.xml", + "ref/netcore50/ja/System.Threading.Tasks.xml", + "ref/netcore50/ko/System.Threading.Tasks.xml", + "ref/netcore50/ru/System.Threading.Tasks.xml", + "ref/netcore50/zh-hans/System.Threading.Tasks.xml", + "ref/netcore50/zh-hant/System.Threading.Tasks.xml", + "ref/netstandard1.0/System.Threading.Tasks.dll", + "ref/netstandard1.0/System.Threading.Tasks.xml", + "ref/netstandard1.0/de/System.Threading.Tasks.xml", + "ref/netstandard1.0/es/System.Threading.Tasks.xml", + "ref/netstandard1.0/fr/System.Threading.Tasks.xml", + "ref/netstandard1.0/it/System.Threading.Tasks.xml", + "ref/netstandard1.0/ja/System.Threading.Tasks.xml", + "ref/netstandard1.0/ko/System.Threading.Tasks.xml", + "ref/netstandard1.0/ru/System.Threading.Tasks.xml", + "ref/netstandard1.0/zh-hans/System.Threading.Tasks.xml", + "ref/netstandard1.0/zh-hant/System.Threading.Tasks.xml", + "ref/netstandard1.3/System.Threading.Tasks.dll", + "ref/netstandard1.3/System.Threading.Tasks.xml", + "ref/netstandard1.3/de/System.Threading.Tasks.xml", + "ref/netstandard1.3/es/System.Threading.Tasks.xml", + "ref/netstandard1.3/fr/System.Threading.Tasks.xml", + "ref/netstandard1.3/it/System.Threading.Tasks.xml", + "ref/netstandard1.3/ja/System.Threading.Tasks.xml", + "ref/netstandard1.3/ko/System.Threading.Tasks.xml", + "ref/netstandard1.3/ru/System.Threading.Tasks.xml", + "ref/netstandard1.3/zh-hans/System.Threading.Tasks.xml", + "ref/netstandard1.3/zh-hant/System.Threading.Tasks.xml", + "ref/portable-net45+win8+wp8+wpa81/_._", + "ref/win8/_._", + "ref/wp80/_._", + "ref/wpa81/_._", + "ref/xamarinios10/_._", + "ref/xamarinmac20/_._", + "ref/xamarintvos10/_._", + "ref/xamarinwatchos10/_._" + ] + }, + "System.Threading.Tasks.Extensions/4.0.0": { + "sha512": "pH4FZDsZQ/WmgJtN4LWYmRdJAEeVkyriSwrv2Teoe5FOU0Yxlb6II6GL8dBPOfRmutHGATduj3ooMt7dJ2+i+w==", + "type": "package", + "path": "System.Threading.Tasks.Extensions/4.0.0", + "files": [ + "System.Threading.Tasks.Extensions.4.0.0.nupkg.sha512", + "System.Threading.Tasks.Extensions.nuspec", + "ThirdPartyNotices.txt", + "dotnet_library_license.txt", + "lib/netstandard1.0/System.Threading.Tasks.Extensions.dll", + "lib/netstandard1.0/System.Threading.Tasks.Extensions.xml", + "lib/portable-net45+win8+wp8+wpa81/System.Threading.Tasks.Extensions.dll", + "lib/portable-net45+win8+wp8+wpa81/System.Threading.Tasks.Extensions.xml" + ] + }, + "System.Threading.Timer/4.0.1": { + "sha512": "saGfUV8uqVW6LeURiqxcGhZ24PzuRNaUBtbhVeuUAvky1naH395A/1nY0P2bWvrw/BreRtIB/EzTDkGBpqCwEw==", + "type": "package", + "path": "System.Threading.Timer/4.0.1", + "files": [ + "System.Threading.Timer.4.0.1.nupkg.sha512", + "System.Threading.Timer.nuspec", + "ThirdPartyNotices.txt", + "dotnet_library_license.txt", + "lib/MonoAndroid10/_._", + "lib/MonoTouch10/_._", + "lib/net451/_._", + "lib/portable-net451+win81+wpa81/_._", + "lib/win81/_._", + "lib/wpa81/_._", + "lib/xamarinios10/_._", + "lib/xamarinmac20/_._", + "lib/xamarintvos10/_._", + "lib/xamarinwatchos10/_._", + "ref/MonoAndroid10/_._", + "ref/MonoTouch10/_._", + "ref/net451/_._", + "ref/netcore50/System.Threading.Timer.dll", + "ref/netcore50/System.Threading.Timer.xml", + "ref/netcore50/de/System.Threading.Timer.xml", + "ref/netcore50/es/System.Threading.Timer.xml", + "ref/netcore50/fr/System.Threading.Timer.xml", + "ref/netcore50/it/System.Threading.Timer.xml", + "ref/netcore50/ja/System.Threading.Timer.xml", + "ref/netcore50/ko/System.Threading.Timer.xml", + "ref/netcore50/ru/System.Threading.Timer.xml", + "ref/netcore50/zh-hans/System.Threading.Timer.xml", + "ref/netcore50/zh-hant/System.Threading.Timer.xml", + "ref/netstandard1.2/System.Threading.Timer.dll", + "ref/netstandard1.2/System.Threading.Timer.xml", + "ref/netstandard1.2/de/System.Threading.Timer.xml", + "ref/netstandard1.2/es/System.Threading.Timer.xml", + "ref/netstandard1.2/fr/System.Threading.Timer.xml", + "ref/netstandard1.2/it/System.Threading.Timer.xml", + "ref/netstandard1.2/ja/System.Threading.Timer.xml", + "ref/netstandard1.2/ko/System.Threading.Timer.xml", + "ref/netstandard1.2/ru/System.Threading.Timer.xml", + "ref/netstandard1.2/zh-hans/System.Threading.Timer.xml", + "ref/netstandard1.2/zh-hant/System.Threading.Timer.xml", + "ref/portable-net451+win81+wpa81/_._", + "ref/win81/_._", + "ref/wpa81/_._", + "ref/xamarinios10/_._", + "ref/xamarinmac20/_._", + "ref/xamarintvos10/_._", + "ref/xamarinwatchos10/_._" + ] + }, + "System.Xml.ReaderWriter/4.0.11": { + "sha512": "ZIiLPsf67YZ9zgr31vzrFaYQqxRPX9cVHjtPSnmx4eN6lbS/yEyYNr2vs1doGDEscF0tjCZFsk9yUg1sC9e8tg==", + "type": "package", + "path": "System.Xml.ReaderWriter/4.0.11", + "files": [ + "System.Xml.ReaderWriter.4.0.11.nupkg.sha512", + "System.Xml.ReaderWriter.nuspec", + "ThirdPartyNotices.txt", + "dotnet_library_license.txt", + "lib/MonoAndroid10/_._", + "lib/MonoTouch10/_._", + "lib/net45/_._", + "lib/netcore50/System.Xml.ReaderWriter.dll", + "lib/netstandard1.3/System.Xml.ReaderWriter.dll", + "lib/portable-net45+win8+wp8+wpa81/_._", + "lib/win8/_._", + "lib/wp80/_._", + "lib/wpa81/_._", + "lib/xamarinios10/_._", + "lib/xamarinmac20/_._", + "lib/xamarintvos10/_._", + "lib/xamarinwatchos10/_._", + "ref/MonoAndroid10/_._", + "ref/MonoTouch10/_._", + "ref/net45/_._", + "ref/netcore50/System.Xml.ReaderWriter.dll", + "ref/netcore50/System.Xml.ReaderWriter.xml", + "ref/netcore50/de/System.Xml.ReaderWriter.xml", + "ref/netcore50/es/System.Xml.ReaderWriter.xml", + "ref/netcore50/fr/System.Xml.ReaderWriter.xml", + "ref/netcore50/it/System.Xml.ReaderWriter.xml", + "ref/netcore50/ja/System.Xml.ReaderWriter.xml", + "ref/netcore50/ko/System.Xml.ReaderWriter.xml", + "ref/netcore50/ru/System.Xml.ReaderWriter.xml", + "ref/netcore50/zh-hans/System.Xml.ReaderWriter.xml", + "ref/netcore50/zh-hant/System.Xml.ReaderWriter.xml", + "ref/netstandard1.0/System.Xml.ReaderWriter.dll", + "ref/netstandard1.0/System.Xml.ReaderWriter.xml", + "ref/netstandard1.0/de/System.Xml.ReaderWriter.xml", + "ref/netstandard1.0/es/System.Xml.ReaderWriter.xml", + "ref/netstandard1.0/fr/System.Xml.ReaderWriter.xml", + "ref/netstandard1.0/it/System.Xml.ReaderWriter.xml", + "ref/netstandard1.0/ja/System.Xml.ReaderWriter.xml", + "ref/netstandard1.0/ko/System.Xml.ReaderWriter.xml", + "ref/netstandard1.0/ru/System.Xml.ReaderWriter.xml", + "ref/netstandard1.0/zh-hans/System.Xml.ReaderWriter.xml", + "ref/netstandard1.0/zh-hant/System.Xml.ReaderWriter.xml", + "ref/netstandard1.3/System.Xml.ReaderWriter.dll", + "ref/netstandard1.3/System.Xml.ReaderWriter.xml", + "ref/netstandard1.3/de/System.Xml.ReaderWriter.xml", + "ref/netstandard1.3/es/System.Xml.ReaderWriter.xml", + "ref/netstandard1.3/fr/System.Xml.ReaderWriter.xml", + "ref/netstandard1.3/it/System.Xml.ReaderWriter.xml", + "ref/netstandard1.3/ja/System.Xml.ReaderWriter.xml", + "ref/netstandard1.3/ko/System.Xml.ReaderWriter.xml", + "ref/netstandard1.3/ru/System.Xml.ReaderWriter.xml", + "ref/netstandard1.3/zh-hans/System.Xml.ReaderWriter.xml", + "ref/netstandard1.3/zh-hant/System.Xml.ReaderWriter.xml", + "ref/portable-net45+win8+wp8+wpa81/_._", + "ref/win8/_._", + "ref/wp80/_._", + "ref/wpa81/_._", + "ref/xamarinios10/_._", + "ref/xamarinmac20/_._", + "ref/xamarintvos10/_._", + "ref/xamarinwatchos10/_._" + ] + }, + "System.Xml.XDocument/4.0.11": { + "sha512": "Mk2mKmPi0nWaoiYeotq1dgeNK1fqWh61+EK+w4Wu8SWuTYLzpUnschb59bJtGywaPq7SmTuPf44wrXRwbIrukg==", + "type": "package", + "path": "System.Xml.XDocument/4.0.11", + "files": [ + "System.Xml.XDocument.4.0.11.nupkg.sha512", + "System.Xml.XDocument.nuspec", + "ThirdPartyNotices.txt", + "dotnet_library_license.txt", + "lib/MonoAndroid10/_._", + "lib/MonoTouch10/_._", + "lib/net45/_._", + "lib/netcore50/System.Xml.XDocument.dll", + "lib/netstandard1.3/System.Xml.XDocument.dll", + "lib/portable-net45+win8+wp8+wpa81/_._", + "lib/win8/_._", + "lib/wp80/_._", + "lib/wpa81/_._", + "lib/xamarinios10/_._", + "lib/xamarinmac20/_._", + "lib/xamarintvos10/_._", + "lib/xamarinwatchos10/_._", + "ref/MonoAndroid10/_._", + "ref/MonoTouch10/_._", + "ref/net45/_._", + "ref/netcore50/System.Xml.XDocument.dll", + "ref/netcore50/System.Xml.XDocument.xml", + "ref/netcore50/de/System.Xml.XDocument.xml", + "ref/netcore50/es/System.Xml.XDocument.xml", + "ref/netcore50/fr/System.Xml.XDocument.xml", + "ref/netcore50/it/System.Xml.XDocument.xml", + "ref/netcore50/ja/System.Xml.XDocument.xml", + "ref/netcore50/ko/System.Xml.XDocument.xml", + "ref/netcore50/ru/System.Xml.XDocument.xml", + "ref/netcore50/zh-hans/System.Xml.XDocument.xml", + "ref/netcore50/zh-hant/System.Xml.XDocument.xml", + "ref/netstandard1.0/System.Xml.XDocument.dll", + "ref/netstandard1.0/System.Xml.XDocument.xml", + "ref/netstandard1.0/de/System.Xml.XDocument.xml", + "ref/netstandard1.0/es/System.Xml.XDocument.xml", + "ref/netstandard1.0/fr/System.Xml.XDocument.xml", + "ref/netstandard1.0/it/System.Xml.XDocument.xml", + "ref/netstandard1.0/ja/System.Xml.XDocument.xml", + "ref/netstandard1.0/ko/System.Xml.XDocument.xml", + "ref/netstandard1.0/ru/System.Xml.XDocument.xml", + "ref/netstandard1.0/zh-hans/System.Xml.XDocument.xml", + "ref/netstandard1.0/zh-hant/System.Xml.XDocument.xml", + "ref/netstandard1.3/System.Xml.XDocument.dll", + "ref/netstandard1.3/System.Xml.XDocument.xml", + "ref/netstandard1.3/de/System.Xml.XDocument.xml", + "ref/netstandard1.3/es/System.Xml.XDocument.xml", + "ref/netstandard1.3/fr/System.Xml.XDocument.xml", + "ref/netstandard1.3/it/System.Xml.XDocument.xml", + "ref/netstandard1.3/ja/System.Xml.XDocument.xml", + "ref/netstandard1.3/ko/System.Xml.XDocument.xml", + "ref/netstandard1.3/ru/System.Xml.XDocument.xml", + "ref/netstandard1.3/zh-hans/System.Xml.XDocument.xml", + "ref/netstandard1.3/zh-hant/System.Xml.XDocument.xml", + "ref/portable-net45+win8+wp8+wpa81/_._", + "ref/win8/_._", + "ref/wp80/_._", + "ref/wpa81/_._", + "ref/xamarinios10/_._", + "ref/xamarinmac20/_._", + "ref/xamarintvos10/_._", + "ref/xamarinwatchos10/_._" + ] + } + }, + "projectFileDependencyGroups": { + "": [], + ".NETPortable,Version=v4.5,Profile=Profile7": [], + ".NETStandard,Version=v1.6": [ + "NETStandard.Library >= 1.6.0" + ] + } +} \ No newline at end of file diff --git a/MediaBrowser.MediaEncoding/MediaBrowser.MediaEncoding.csproj b/MediaBrowser.MediaEncoding/MediaBrowser.MediaEncoding.csproj index 3b017cc4eb..8f8a7a8191 100644 --- a/MediaBrowser.MediaEncoding/MediaBrowser.MediaEncoding.csproj +++ b/MediaBrowser.MediaEncoding/MediaBrowser.MediaEncoding.csproj @@ -37,14 +37,6 @@ <WarningLevel>4</WarningLevel> </PropertyGroup> <ItemGroup> - <Reference Include="BDInfo, Version=1.0.1.0, Culture=neutral, processorArchitecture=MSIL"> - <HintPath>..\packages\MediaBrowser.BdInfo.1.0.1\lib\portable-net46+win10\BDInfo.dll</HintPath> - <Private>True</Private> - </Reference> - <Reference Include="DvdLib, Version=1.0.1.0, Culture=neutral, processorArchitecture=MSIL"> - <HintPath>..\packages\MediaBrowser.BdInfo.1.0.1\lib\portable-net46+win10\DvdLib.dll</HintPath> - <Private>True</Private> - </Reference> <Reference Include="System" /> <Reference Include="System.Core" /> <Reference Include="System.Xml.Linq" /> @@ -91,6 +83,10 @@ <Compile Include="Subtitles\VttWriter.cs" /> </ItemGroup> <ItemGroup> + <ProjectReference Include="..\..\BdInfo\BDInfo\BDInfo.csproj"> + <Project>{88ae38df-19d7-406f-a6a9-09527719a21e}</Project> + <Name>BDInfo</Name> + </ProjectReference> <ProjectReference Include="..\MediaBrowser.Common\MediaBrowser.Common.csproj"> <Project>{9142eefa-7570-41e1-bfcc-468bb571af2f}</Project> <Name>MediaBrowser.Common</Name> @@ -108,9 +104,6 @@ <Name>OpenSubtitlesHandler</Name> </ProjectReference> </ItemGroup> - <ItemGroup> - <None Include="packages.config" /> - </ItemGroup> <ItemGroup> <EmbeddedResource Include="Probing\whitelist.txt" /> </ItemGroup> diff --git a/MediaBrowser.MediaEncoding/packages.config b/MediaBrowser.MediaEncoding/packages.config deleted file mode 100644 index 23875a1397..0000000000 --- a/MediaBrowser.MediaEncoding/packages.config +++ /dev/null @@ -1,4 +0,0 @@ -<?xml version="1.0" encoding="utf-8"?> -<packages> - <package id="MediaBrowser.BdInfo" version="1.0.1" targetFramework="net46" /> -</packages> \ No newline at end of file diff --git a/MediaBrowser.Providers/MediaBrowser.Providers.csproj b/MediaBrowser.Providers/MediaBrowser.Providers.csproj index 4808dae1a2..016fa2ebd0 100644 --- a/MediaBrowser.Providers/MediaBrowser.Providers.csproj +++ b/MediaBrowser.Providers/MediaBrowser.Providers.csproj @@ -42,14 +42,6 @@ <WarningLevel>4</WarningLevel> </PropertyGroup> <ItemGroup> - <Reference Include="BDInfo, Version=1.0.1.0, Culture=neutral, processorArchitecture=MSIL"> - <HintPath>..\packages\MediaBrowser.BdInfo.1.0.1\lib\portable-net46+win10\BDInfo.dll</HintPath> - <Private>True</Private> - </Reference> - <Reference Include="DvdLib, Version=1.0.1.0, Culture=neutral, processorArchitecture=MSIL"> - <HintPath>..\packages\MediaBrowser.BdInfo.1.0.1\lib\portable-net46+win10\DvdLib.dll</HintPath> - <Private>True</Private> - </Reference> <Reference Include="System" /> <Reference Include="System.Core" /> <Reference Include="System.Net" /> @@ -139,6 +131,7 @@ <Compile Include="TV\FanArt\FanArtSeasonProvider.cs" /> <Compile Include="TV\FanArt\FanartSeriesProvider.cs" /> <Compile Include="TV\MissingEpisodeProvider.cs" /> + <Compile Include="TV\SeriesPostScanTask.cs" /> <Compile Include="TV\TheMovieDb\MovieDbProviderBase.cs" /> <Compile Include="TV\TheMovieDb\MovieDbEpisodeImageProvider.cs" /> <Compile Include="TV\TheMovieDb\MovieDbSeasonProvider.cs" /> @@ -154,7 +147,6 @@ <Compile Include="TV\SeasonMetadataService.cs" /> <Compile Include="TV\TheTVDB\TvdbEpisodeProvider.cs" /> <Compile Include="TV\TheTVDB\TvdbSeriesProvider.cs" /> - <Compile Include="TV\SeriesPostScanTask.cs" /> <Compile Include="TV\TheTVDB\TvdbPrescanTask.cs" /> <Compile Include="TV\TvExternalIds.cs" /> <Compile Include="Users\UserMetadataService.cs" /> @@ -162,6 +154,10 @@ <Compile Include="Years\YearMetadataService.cs" /> </ItemGroup> <ItemGroup> + <ProjectReference Include="..\DvdLib\DvdLib.csproj"> + <Project>{713f42b5-878e-499d-a878-e4c652b1d5e8}</Project> + <Name>DvdLib</Name> + </ProjectReference> <ProjectReference Include="..\MediaBrowser.Common\MediaBrowser.Common.csproj"> <Project>{9142EEFA-7570-41E1-BFCC-468BB571AF2F}</Project> <Name>MediaBrowser.Common</Name> @@ -175,9 +171,6 @@ <Name>MediaBrowser.Model</Name> </ProjectReference> </ItemGroup> - <ItemGroup> - <None Include="packages.config" /> - </ItemGroup> <ItemGroup /> <Import Project="$(MSBuildToolsPath)\Microsoft.CSharp.targets" /> <!-- To modify your build process, add your task inside one of the targets below and uncomment it. diff --git a/MediaBrowser.Providers/MediaInfo/FFProbeVideoInfo.cs b/MediaBrowser.Providers/MediaInfo/FFProbeVideoInfo.cs index 2720c61d62..8dc4c42902 100644 --- a/MediaBrowser.Providers/MediaInfo/FFProbeVideoInfo.cs +++ b/MediaBrowser.Providers/MediaInfo/FFProbeVideoInfo.cs @@ -607,7 +607,7 @@ private void OnPreFetch(Video item, IIsoMount mount, BlurayDiscInfo blurayDiscIn private void FetchFromDvdLib(Video item, IIsoMount mount) { var path = mount == null ? item.Path : mount.MountedPath; - var dvd = new Dvd(path); + var dvd = new Dvd(path, _fileSystem); var primaryTitle = dvd.Titles.OrderByDescending(GetRuntime).FirstOrDefault(); diff --git a/MediaBrowser.Providers/packages.config b/MediaBrowser.Providers/packages.config deleted file mode 100644 index 23875a1397..0000000000 --- a/MediaBrowser.Providers/packages.config +++ /dev/null @@ -1,4 +0,0 @@ -<?xml version="1.0" encoding="utf-8"?> -<packages> - <package id="MediaBrowser.BdInfo" version="1.0.1" targetFramework="net46" /> -</packages> \ No newline at end of file diff --git a/MediaBrowser.sln b/MediaBrowser.sln index e8ceff89b8..b8427b544e 100644 --- a/MediaBrowser.sln +++ b/MediaBrowser.sln @@ -64,6 +64,10 @@ Project("{FAE04EC0-301F-11D3-BF4B-00C04F79EFBC}") = "Mono.Nat", "Mono.Nat\Mono.N EndProject Project("{FAE04EC0-301F-11D3-BF4B-00C04F79EFBC}") = "Emby.Photos", "Emby.Photos\Emby.Photos.csproj", "{89AB4548-770D-41FD-A891-8DAFF44F452C}" EndProject +Project("{FAE04EC0-301F-11D3-BF4B-00C04F79EFBC}") = "DvdLib", "DvdLib\DvdLib.csproj", "{713F42B5-878E-499D-A878-E4C652B1D5E8}" +EndProject +Project("{FAE04EC0-301F-11D3-BF4B-00C04F79EFBC}") = "BDInfo", "..\BdInfo\BDInfo\BDInfo.csproj", "{88AE38DF-19D7-406F-A6A9-09527719A21E}" +EndProject Global GlobalSection(SolutionConfigurationPlatforms) = preSolution Debug|Any CPU = Debug|Any CPU @@ -540,6 +544,66 @@ Global {89AB4548-770D-41FD-A891-8DAFF44F452C}.Release|x64.Build.0 = Release|Any CPU {89AB4548-770D-41FD-A891-8DAFF44F452C}.Release|x86.ActiveCfg = Release|Any CPU {89AB4548-770D-41FD-A891-8DAFF44F452C}.Release|x86.Build.0 = Release|Any CPU + {713F42B5-878E-499D-A878-E4C652B1D5E8}.Debug|Any CPU.ActiveCfg = Debug|Any CPU + {713F42B5-878E-499D-A878-E4C652B1D5E8}.Debug|Any CPU.Build.0 = Debug|Any CPU + {713F42B5-878E-499D-A878-E4C652B1D5E8}.Debug|Mixed Platforms.ActiveCfg = Debug|Any CPU + {713F42B5-878E-499D-A878-E4C652B1D5E8}.Debug|Mixed Platforms.Build.0 = Debug|Any CPU + {713F42B5-878E-499D-A878-E4C652B1D5E8}.Debug|Win32.ActiveCfg = Debug|Any CPU + {713F42B5-878E-499D-A878-E4C652B1D5E8}.Debug|Win32.Build.0 = Debug|Any CPU + {713F42B5-878E-499D-A878-E4C652B1D5E8}.Debug|x64.ActiveCfg = Debug|Any CPU + {713F42B5-878E-499D-A878-E4C652B1D5E8}.Debug|x64.Build.0 = Debug|Any CPU + {713F42B5-878E-499D-A878-E4C652B1D5E8}.Debug|x86.ActiveCfg = Debug|Any CPU + {713F42B5-878E-499D-A878-E4C652B1D5E8}.Debug|x86.Build.0 = Debug|Any CPU + {713F42B5-878E-499D-A878-E4C652B1D5E8}.Release Mono|Any CPU.ActiveCfg = Release|Any CPU + {713F42B5-878E-499D-A878-E4C652B1D5E8}.Release Mono|Any CPU.Build.0 = Release|Any CPU + {713F42B5-878E-499D-A878-E4C652B1D5E8}.Release Mono|Mixed Platforms.ActiveCfg = Release|Any CPU + {713F42B5-878E-499D-A878-E4C652B1D5E8}.Release Mono|Mixed Platforms.Build.0 = Release|Any CPU + {713F42B5-878E-499D-A878-E4C652B1D5E8}.Release Mono|Win32.ActiveCfg = Release|Any CPU + {713F42B5-878E-499D-A878-E4C652B1D5E8}.Release Mono|Win32.Build.0 = Release|Any CPU + {713F42B5-878E-499D-A878-E4C652B1D5E8}.Release Mono|x64.ActiveCfg = Release|Any CPU + {713F42B5-878E-499D-A878-E4C652B1D5E8}.Release Mono|x64.Build.0 = Release|Any CPU + {713F42B5-878E-499D-A878-E4C652B1D5E8}.Release Mono|x86.ActiveCfg = Release|Any CPU + {713F42B5-878E-499D-A878-E4C652B1D5E8}.Release Mono|x86.Build.0 = Release|Any CPU + {713F42B5-878E-499D-A878-E4C652B1D5E8}.Release|Any CPU.ActiveCfg = Release|Any CPU + {713F42B5-878E-499D-A878-E4C652B1D5E8}.Release|Any CPU.Build.0 = Release|Any CPU + {713F42B5-878E-499D-A878-E4C652B1D5E8}.Release|Mixed Platforms.ActiveCfg = Release|Any CPU + {713F42B5-878E-499D-A878-E4C652B1D5E8}.Release|Mixed Platforms.Build.0 = Release|Any CPU + {713F42B5-878E-499D-A878-E4C652B1D5E8}.Release|Win32.ActiveCfg = Release|Any CPU + {713F42B5-878E-499D-A878-E4C652B1D5E8}.Release|Win32.Build.0 = Release|Any CPU + {713F42B5-878E-499D-A878-E4C652B1D5E8}.Release|x64.ActiveCfg = Release|Any CPU + {713F42B5-878E-499D-A878-E4C652B1D5E8}.Release|x64.Build.0 = Release|Any CPU + {713F42B5-878E-499D-A878-E4C652B1D5E8}.Release|x86.ActiveCfg = Release|Any CPU + {713F42B5-878E-499D-A878-E4C652B1D5E8}.Release|x86.Build.0 = Release|Any CPU + {88AE38DF-19D7-406F-A6A9-09527719A21E}.Debug|Any CPU.ActiveCfg = Debug|Any CPU + {88AE38DF-19D7-406F-A6A9-09527719A21E}.Debug|Any CPU.Build.0 = Debug|Any CPU + {88AE38DF-19D7-406F-A6A9-09527719A21E}.Debug|Mixed Platforms.ActiveCfg = Debug|Any CPU + {88AE38DF-19D7-406F-A6A9-09527719A21E}.Debug|Mixed Platforms.Build.0 = Debug|Any CPU + {88AE38DF-19D7-406F-A6A9-09527719A21E}.Debug|Win32.ActiveCfg = Debug|Any CPU + {88AE38DF-19D7-406F-A6A9-09527719A21E}.Debug|Win32.Build.0 = Debug|Any CPU + {88AE38DF-19D7-406F-A6A9-09527719A21E}.Debug|x64.ActiveCfg = Debug|Any CPU + {88AE38DF-19D7-406F-A6A9-09527719A21E}.Debug|x64.Build.0 = Debug|Any CPU + {88AE38DF-19D7-406F-A6A9-09527719A21E}.Debug|x86.ActiveCfg = Debug|Any CPU + {88AE38DF-19D7-406F-A6A9-09527719A21E}.Debug|x86.Build.0 = Debug|Any CPU + {88AE38DF-19D7-406F-A6A9-09527719A21E}.Release Mono|Any CPU.ActiveCfg = Release|Any CPU + {88AE38DF-19D7-406F-A6A9-09527719A21E}.Release Mono|Any CPU.Build.0 = Release|Any CPU + {88AE38DF-19D7-406F-A6A9-09527719A21E}.Release Mono|Mixed Platforms.ActiveCfg = Release|Any CPU + {88AE38DF-19D7-406F-A6A9-09527719A21E}.Release Mono|Mixed Platforms.Build.0 = Release|Any CPU + {88AE38DF-19D7-406F-A6A9-09527719A21E}.Release Mono|Win32.ActiveCfg = Release|Any CPU + {88AE38DF-19D7-406F-A6A9-09527719A21E}.Release Mono|Win32.Build.0 = Release|Any CPU + {88AE38DF-19D7-406F-A6A9-09527719A21E}.Release Mono|x64.ActiveCfg = Release|Any CPU + {88AE38DF-19D7-406F-A6A9-09527719A21E}.Release Mono|x64.Build.0 = Release|Any CPU + {88AE38DF-19D7-406F-A6A9-09527719A21E}.Release Mono|x86.ActiveCfg = Release|Any CPU + {88AE38DF-19D7-406F-A6A9-09527719A21E}.Release Mono|x86.Build.0 = Release|Any CPU + {88AE38DF-19D7-406F-A6A9-09527719A21E}.Release|Any CPU.ActiveCfg = Release|Any CPU + {88AE38DF-19D7-406F-A6A9-09527719A21E}.Release|Any CPU.Build.0 = Release|Any CPU + {88AE38DF-19D7-406F-A6A9-09527719A21E}.Release|Mixed Platforms.ActiveCfg = Release|Any CPU + {88AE38DF-19D7-406F-A6A9-09527719A21E}.Release|Mixed Platforms.Build.0 = Release|Any CPU + {88AE38DF-19D7-406F-A6A9-09527719A21E}.Release|Win32.ActiveCfg = Release|Any CPU + {88AE38DF-19D7-406F-A6A9-09527719A21E}.Release|Win32.Build.0 = Release|Any CPU + {88AE38DF-19D7-406F-A6A9-09527719A21E}.Release|x64.ActiveCfg = Release|Any CPU + {88AE38DF-19D7-406F-A6A9-09527719A21E}.Release|x64.Build.0 = Release|Any CPU + {88AE38DF-19D7-406F-A6A9-09527719A21E}.Release|x86.ActiveCfg = Release|Any CPU + {88AE38DF-19D7-406F-A6A9-09527719A21E}.Release|x86.Build.0 = Release|Any CPU EndGlobalSection GlobalSection(SolutionProperties) = preSolution HideSolutionNode = FALSE diff --git a/packages/MediaBrowser.BdInfo.1.0.1/MediaBrowser.BdInfo.1.0.1.nupkg b/packages/MediaBrowser.BdInfo.1.0.1/MediaBrowser.BdInfo.1.0.1.nupkg deleted file mode 100644 index 8682c1467eaac8a6ad4c6cd75de1144a43d0f75b..0000000000000000000000000000000000000000 GIT binary patch literal 0 HcmV?d00001 literal 49484 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%0DO_5&qR2 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 D!NIxZ diff --git a/packages/MediaBrowser.BdInfo.1.0.1/lib/portable-net46+win10/BDInfo.dll b/packages/MediaBrowser.BdInfo.1.0.1/lib/portable-net46+win10/BDInfo.dll deleted file mode 100644 index 0026af72db827571b2c3f10c62548469f2cab3d4..0000000000000000000000000000000000000000 GIT binary patch literal 0 HcmV?d00001 literal 87552 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 yrR;5 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 diff --git a/packages/MediaBrowser.BdInfo.1.0.1/lib/portable-net46+win10/DvdLib.dll b/packages/MediaBrowser.BdInfo.1.0.1/lib/portable-net46+win10/DvdLib.dll deleted file mode 100644 index bdceeb79f6496098a00016863d89a1be77fd79cc..0000000000000000000000000000000000000000 GIT binary patch literal 0 HcmV?d00001 literal 17920 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 Xf7(xv^Z$%^27j^jU!VW~df@*8p|O%?