code: def _nest_at_rules(self, rule, scope, block):
          
          # TODO handle @charset, probably?
          # Interpolate the current block
          # TODO this seems like it should be done in the block header.  and more
          # generally?
          calculator = self._make_calculator(rule.namespace)
          if block.header.argument:
              # TODO is this correct?  do ALL at-rules ALWAYS allow both vars and
              # interpolation?
              node = calculator.parse_vars_and_interpolations(
                  block.header.argument)
              block.header.argument = node.evaluate(calculator).render()
  
          # TODO merge into RuleAncestry
          new_ancestry = list(rule.ancestry.headers)
          if block.directive == '@media' and new_ancestry:
              for i, header in reversed(list(enumerate(new_ancestry))):
                  if header.is_selector:
                      continue
                  elif header.directive == '@media':
                      new_ancestry[i] = BlockAtRuleHeader(
                          '@media',
                          "%s and %s" % (header.argument, block.argument))
                      break
                  else:
                      new_ancestry.insert(i, block.header)
              else:
                  new_ancestry.insert(0, block.header)
          else:
              new_ancestry.append(block.header)
  
          rule.descendants += 1
          new_rule = SassRule(
              source_file=rule.source_file,
              import_key=rule.import_key,
              lineno=block.lineno,
              num_header_lines=block.header.num_lines,
              unparsed_contents=block.unparsed_contents,
  
              legacy_compiler_options=rule.legacy_compiler_options,
              options=rule.options.copy(),
              #properties
              #extends_selectors
              ancestry=RuleAncestry(new_ancestry),
  
              namespace=rule.namespace.derive(),
              nested=rule.nested + 1,
          )
          self.rules.append(new_rule)
          rule.namespace.use_import(rule.source_file)
          self.manage_children(new_rule, scope)
  
          self._warn_unused_imports(new_rule)
docs: Implements @-blocks