<p><code>List of <a href="../build-ref.html#labels">labels</a>; optional</code></p>

<p>
The list of files needed by this rule at runtime.
</p>

<p>
Targets named in the <code>data</code> attribute will appear in
the <code>*.runfiles</code> area of this rule, if it has one.  This
may include data files needed by a binary or library, or other
programs needed by it.  See the
<a href="../build-ref.html#data">data dependencies</a> section for more
information about how to depend on and use data files.
</p>

<p>
Almost all rules permit a <code>data</code> attribute, but where
this attribute is not allowed, this fact is documented under the
specific rule.
</p>
