     /**
      * Retrieves a class definition from the loaded swf.
      *
-     * @throws IllegalOperationError when the swf has not completed loading or the class does
-     * not exist
+     * @throws flash.errors.IllegalOperationError when the swf has not completed loading
+     * or the class does not exist.
      */
     public function getClass (className :String) :Class
     {

    /**
     * Checks if a symbol exists in the library.
     *
     * @throws IllegalOperationError when the swf has not completed loading.
     */
    public function isSymbol (className :String) :Boolean
    {

import flash.system.LoaderContext;

/**
 * Allows you to load an embeded SWF stored as a ByteArray then access any stored classes
 * within the SWF.
 * 
 * An Event.COMPLETE will be dispatched upon the successful completion of a call to
 * <code>load</code>.  IOErrorEvent.IO_ERROR will be dispatched if there's a problem reading the
 * ByteArray.
 *
 * Embed your swf like this (take note of the mimeType!):
 * <code><pre>
 * [Embed(source="foo.swf", mimeType="application/octet-stream")]
 * private static const FOO_RESOURCE :Class;
 * </pre></code>
 *
 * Then:
 *
 * <code><pre>
 * var loader :EmbeddedSwfLoader = new EmbeddedSwfLoader();
 * loader.addEventListener(Event.COMPLETE, handleComplete);
 * loader.addEventListener(IOErrorEvent.IO_ERROR, handleFailure);
 * loader.load(FOO_RESOURCE);
 *
 * ...
 * function handleComplete (event :Event) :void
 * {
 *     var myMovie = loader.getContent();
 * ...
 * </pre></code>
 *
 * @deprecated Content packs are coming, and symbols can be embedded directly
 * by using [Embed(source="foo.swf#somesymbol")]
 */
public class EmbeddedSwfLoader extends EventDispatcher 
{
    /**
     * Create an EmbeddedSwfLoader, good for loading one SWF from a ByteArray.
     *
     * @param useSubDomain if true, load the SWF and all its classes and symbols into a
     *  child ApplicationDomain. This means that they would be not normally reachable by the rest
     *  of your code after they're loaded, you would only be able to access the contents using
     *  this EmbeddedSwfLoader. This also means that those classes or symbols won't interfere
     *  with others loaded with the same name, and the classes can be garbage collected when
     *  no longer in use.
     */
    public function EmbeddedSwfLoader (useSubDomain :Boolean = false)
    {
        _useSubDomain = useSubDomain;
        _loader = new Loader();
        _loader.contentLoaderInfo.addEventListener(Event.COMPLETE, dispatchEvent);
        _loader.contentLoaderInfo.addEventListener(IOErrorEvent.IO_ERROR, dispatchEvent);
    }

    /**
     * Load the SWF from a ByteArray. A COMPLETE event will be dispatched on successful 
     * completion of the load. If any errors occur, a IO_ERROR event will be dispatched.
     *
     * @throws TypeError The parameter must be a ByteArray, or a Class that becomes one. If AS
     * had overloading, this wouldn't be necessary, we could catch these problems at compile time.
     *
     * @param byteArrayOrClass a flash.utils.ByteArray or a Class object that becomes one.
     */
    public function load (byteArrayOrClass :Object) :void
    {
        var byteArray :ByteArray = ByteArray( // this cast may throw a TypeError
            (byteArrayOrClass is Class) ? new (byteArrayOrClass as Class)() // voila!
                                        : byteArrayOrClass); // and wa-la!

        var context :LoaderContext = new LoaderContext();
        context.applicationDomain = _useSubDomain ? 
            new ApplicationDomain(ApplicationDomain.currentDomain) : 
            ApplicationDomain.currentDomain;
        _loader.loadBytes(byteArray, context);
    }

// This doesn't work. We cannot write parameters to the contentLoaderInfo.
