<!doctype html>
<html lang="en">
  <head>
    <meta charset="utf-8">
    <meta http-equiv="X-UA-Compatible" content="IE=edge">
    <meta name="description" content="A front-end template that helps you build fast, modern mobile web apps.">
    <meta name="viewport" content="width=device-width, initial-scale=1">
    <title>spinner test</title>

        <!-- Fonts -->
    <link href='https://fonts.googleapis.com/css?family=Roboto:regular,bold,italic,thin,light,bolditalic,black,medium&amp;lang=en' rel='stylesheet' type='text/css'>
    <link href="https://fonts.googleapis.com/icon?family=Material+Icons"
      rel="stylesheet">

    <!-- Page styles -->
    <link rel="stylesheet" href="https://cdnjs.cloudflare.com/ajax/libs/prism/0.0.1/prism.min.css">
    <link rel="stylesheet" href="../../material.min.css">
    <link rel="stylesheet" href="../../components/demos.css">
    <script src="../../material.min.js"></script>

    
    <style>
      
    </style>

  </head>
  <body>

    <div style="padding-top: 24px;">
      
        
<!-- MDL Spinner Component -->
<div class="mdl-spinner mdl-js-spinner is-active"></div>

<!-- MDL Spinner Component with Single Color -->
<div class="mdl-spinner mdl-spinner--single-color mdl-js-spinner is-active"></div>

      
    </div>
    <!-- Built with love using Material Design Lite -->

    
    <script>
      
    </script>
  </body>
</html>
