// Loading a language resource module:
resourceManager.loadResourceModule('http://aaronhardy.com/en_US_ResourceModule.swf');
 
// Loading a style module (e.g., a compiled font swf):
StyleManager.loadStyleDeclarations("http://aaronhardy.com/fonts/Astroid.swf");
 
// Loading miscellaneous modules:
var moduleInfo:IModuleInfo = ModuleManager.getModule('http://aaronhardy.com/MyModule.swf');
moduleInfo.load();

Unable to load resource module from http://aaronhardy.com/en_US_ResourceModule.swf
Error: Unable to load style(SWF is not a loadable module): http://aaronhardy.com/fonts/Astroid.swf.

package com.aaronhardy
{
	import flash.events.ErrorEvent;
	import flash.events.Event;
	import flash.events.EventDispatcher;
	import flash.events.IOErrorEvent;
	import flash.events.SecurityErrorEvent;
	import flash.net.URLLoader;
	import flash.net.URLLoaderDataFormat;
	import flash.net.URLRequest;
	import flash.utils.ByteArray;
 
	import mx.events.ModuleEvent;
	import mx.modules.IModuleInfo;
	import mx.modules.ModuleManager;
 
	/**
	 * Dispatched once module loading is complete.
	 */
	[Event(name="ready", type="mx.events.ModuleEvent")]
 
	/**
	 * Dispatched if an error is encountered while loading the module.
	 */
	[Event(name="error", type="mx.events.ModuleEvent")]
 
	/**
	 * Loads a remote module.  Specifically, this is a workaround to allow an application being run
	 * locally (not using a web server) to load a module residing on a remote server.
	 * Usually, when attemping to do so using resourceManager.loadResourceModule(),
	 * StyleManager.loadStyleDeclarations(), or IModuleInfo.load() without passing in bytes
	 * results in errors such as the following:
	 *
	 * Error: Unable to load resource module from http://aaronhardy.com/locales/en_US.swf
	 * Error: Unable to load style(SWF is not a loadable module): http://aaronhardy.com/fonts/Astroid.swf.
	 *
	 * Be aware that any module imported with this class may have access to anything within
	 * your application's security sandbox.
	 */
	public class ModuleMarshaller extends EventDispatcher
	{
		protected var url:String;
 
		/**
		 * Appears to need to be stored in the class scope, otherwise garbage collection
		 * wipes out some of the event handling within IModuleInfo.
		 */
		protected var module:IModuleInfo;
 
		/**
		 * Constructor.
		 * @param url The external module to load into the application.
		 */
		public function ModuleMarshaller(url:String)
		{
			this.url = url;
		}
 
		/**
		 * Starts the loading process by loading in the module as bytes.
		 */
		public function loadModule():URLLoader
		{
			var urlRequest:URLRequest = new URLRequest(url);
			var urlLoader:URLLoader = new URLLoader(urlRequest);
			urlLoader.dataFormat = URLLoaderDataFormat.BINARY;
			urlLoader.addEventListener(Event.COMPLETE, bytesLoadedHandler);
			urlLoader.addEventListener(IOErrorEvent.IO_ERROR, errorHandler);
			urlLoader.addEventListener(SecurityErrorEvent.SECURITY_ERROR, errorHandler);
			return urlLoader;
		}
 
		/**
		 * Once the module bytes are loaded, convert them back into a module within the
		 * application's security domain.
		 */
		protected function bytesLoadedHandler(event:Event):void
		{
			var styleModuleBytes:ByteArray = ByteArray(URLLoader(event.target).data);
			module = ModuleManager.getModule(url);
			module.addEventListener(ModuleEvent.READY, modReadyHandler);
			module.addEventListener(ModuleEvent.ERROR, errorHandler);
			module.load(null, null, styleModuleBytes);
		}
 
		/**
		 * Once the module information is loaded, use the factory to create an instance of the
		 * module.
		 */
		protected function modReadyHandler(event:ModuleEvent):void
		{
			ModuleManager.getModule(url).factory.create();
			dispatchEvent(event.clone());
		}
 
		/**
		 * Reports errors that may have occurred.
		 */
		protected function errorHandler(event:Event):void
		{
			if (event is ModuleEvent)
			{
				dispatchEvent(event.clone());
			}
			else if (event is ErrorEvent)
			{
				dispatchEvent(new ModuleEvent(ModuleEvent.ERROR, false, false, 0, 0,
					ErrorEvent(event).text));
			}
		}
 
	}
}

package com.aaronhardy
{
	import mx.events.ModuleEvent;
 
	/**
	 * Provides the module marshalling functionality of ModuleMarshaller with the ability to
	 * update styles immediately after the module is loaded.
	 */
	public class StyleModuleMarshaller extends ModuleMarshaller
	{
		/**
		 * If true, forces an immediate update of the application's styles after the module is
		 * loaded.
		 */
		protected var updateStylesImmediately:Boolean = true;
 
		/**
		 * Constructor.
		 * @param url The external module to load into the application.
		 * @param update If true, forces an immediate update of the application's styles after
		 *        the module is loaded.
		 */
		public function StyleModuleMarshaller(url:String, updateStylesImmediately:Boolean=true)
		{
			super(url);
			this.updateStylesImmediately = updateStylesImmediately;
		}
 
		/**
		 * @inheritDoc
		 */
		override protected function modReadyHandler(event:ModuleEvent):void
		{
			ModuleManager.getModule(url).factory.create();
 
			if (updateStylesImmediately)
			{
				mx.core.Singleton.getInstance("mx.styles::IStyleManager2").styleDeclarationsChanged();
			}
 
			dispatchEvent(event.clone());
		}
	}
}

factoryInfo = new FactoryInfo();
 
try
{
    factoryInfo.factory = loader.content as IFlexModuleFactory;
}
catch(error:Error)
{
}
 
if (!factoryInfo.factory)
{
    var moduleEvent:ModuleEvent = new ModuleEvent(
        ModuleEvent.ERROR, event.bubbles, event.cancelable);
    moduleEvent.bytesLoaded = 0;
    moduleEvent.bytesTotal = 0;
    moduleEvent.errorText = "SWF is not a loadable module";
    dispatchEvent(moduleEvent);
    return;
}

module.load(null, null, styleModuleBytes);