externalinterface

//class ExternalInterface
package flash.external
{
    import flash.system.*;
    import flash.utils.*;

    public final class ExternalInterface extends Object
    {
        public function ExternalInterface()
        {
            super();
            return;
        }

        public static function get available():Boolean
        {
        }

        public static function addCallback(arg1:String, arg2:Function):void
        {
            var functionName:String;
            var closure:Function;
            var hasNullCallback:Boolean;
            var wrapperClosure:Function;

            var loc1:*;
            hasNullCallback = false;
            wrapperClosure = null;
            functionName = arg1;
            closure = arg2;
            if (available)
            {
                _initJS();
                hasNullCallback = closure == null;
                wrapperClosure = function (arg1:String, arg2:Array):String
                {
                    return _callIn(closure, arg1, arg2);
                }
                _addCallback(functionName, wrapperClosure, hasNullCallback);
                if (activeX == true && !(objectID == null))
                {
                    _evalJS("__flash__addCallback(document.getElementById(\"" + objectID + "\"), \"" + functionName + "\");");
                }
            }
            else
            {
                Error.throwError(Error, 2067);
            }
            return;
        }

        public static function call(arg1:String, ... rest):*
        {
            var loc1:*=null;
            var loc2:*=null;
            var loc3:*=false;
            var loc4:*=0;
            var loc5:*=null;
            var loc6:*=null;
            var loc7:*=false;
            var loc8:*=null;
            if (available)
            {
                loc1 = "";
                _initJS();
                loc1 = loc1 + "try { ";
                loc2 = objectID;
                loc3 = activeX;
                if (loc3 == true && !(loc2 == null))
                {
                    loc1 = loc1 + ("document.getElementById(\"" + loc2 + "\").SetReturnValue(");
                }
                loc1 = loc1 + ("__flash__toXML(" + arg1 + "(");
                loc4 = 0;
                while (loc4 < rest.length)
                {
                    if (loc4 != 0)
                    {
                        loc1 = loc1 + ",";
                    }
                    loc1 = loc1 + _toJS(rest[loc4]);
                    ++loc4;
                }
                loc1 = loc1 + ")) ";
                if (loc3 == true && !(loc2 == null))
                {
                    loc1 = loc1 + ")";
                }
                loc1 = loc1 + "; } catch (e) { ";
                if (loc3 == true && !(loc2 == null))
                {
                    if (marshallExceptions)
                    {
                        loc1 = loc1 + ("document.getElementById(\"" + loc2 + "\").SetReturnValue(\"<exception>\" + e + \"</exception>\");");
                    }
                    else
                    {
                        loc1 = loc1 + ("document.getElementById(\"" + loc2 + "\").SetReturnValue(\"<undefined/>\");");
                    }
                }
                else if (marshallExceptions)
                {
                    loc1 = loc1 + "\"<exception>\" + e + \"</exception>\";";
                }
                else
                {
                    loc1 = loc1 + "\"<undefined/>\";";
                }
                loc1 = loc1 + " }";
                loc5 = _evalJS(loc1);
                if (loc5 == null)
                {
                    loc6 = "<invoke name=\"" + arg1 + "\" returntype=\"xml\">" + _argumentsToXML(rest) + "</invoke>";
                    loc5 = _callOut(loc6);
                }
                if (loc5 == null)
                {
                    return null;
                }
                loc7 = XML.ignoreWhitespace;
                if (Capabilities.version.split(new RegExp("[\\ ,]"))[1] > 9)
                {
                    XML.ignoreWhitespace = false;
                }
                loc8 = XML(loc5);
                XML.ignoreWhitespace = loc7;
                return _toAS(loc8);
            }
            Error.throwError(Error, 2067);
            return;
        }

        private static function _initJS():void
        {
        }

        private static function _getPropNames(arg1:Object):Array
        {
        }

        public static function get objectID():String
        {
        }

        private static function get activeX():Boolean
        {
        }

        private static function _addCallback(arg1:String, arg2:Function, arg3:Boolean):void
        {
        }

        private static function _evalJS(arg1:String):String
        {
        }

        private static function _callOut(arg1:String):String
        {
        }

        private static function _callIn(arg1:Function, arg2:String, arg3:Array):String
        {
            var closure:Function;
            var request:String;
            var args:Array;
            var arguments:Array;
            var oldIgnoreWhitespace:Boolean;
            var xml:XML;
            var result:*;

            var loc1:*;
            result = undefined;
            closure = arg1;
            request = arg2;
            args = arg3;
            arguments = arguments;
            if (args != null)
            {
                try
                {
                    result = closure.apply(null, args);
                }
                catch (e:Error)
                {
                    if (marshallExceptions)
                    {
                        result = e;
                    }
                    else
                    {
                        throw e;
                    }
                }
                return _toJS(result);
            }
            oldIgnoreWhitespace = XML.ignoreWhitespace;
            XML.ignoreWhitespace = false;
            xml = XML(request);
            XML.ignoreWhitespace = oldIgnoreWhitespace;
            try
            {
                result = closure.apply(null, _argumentsToAS(xml.arguments));
            }
            catch (e:Error)
            {
                if (marshallExceptions)
                {
                    result = e;
                }
                else
                {
                    throw e;
                }
            }
            return xml.@returntype != "javascript" ? _toXML(result) : _toJS(result);
        }

        private static function _arrayToXML(arg1:Array):String
        {
            var loc1:*="<array>";
            var loc2:*=0;
            while (loc2 < arg1.length)
            {
                loc1 = loc1 + ("<property id=\"" + loc2 + "\">" + _toXML(arg1[loc2]) + "</property>");
                ++loc2;
            }
            return loc1 + "</array>";
        }

        private static function _argumentsToXML(arg1:Array):String
        {
            var loc1:*="<arguments>";
            var loc2:*=0;
            while (loc2 < arg1.length)
            {
                loc1 = loc1 + _toXML(arg1[loc2]);
                ++loc2;
            }
            return loc1 + "</arguments>";
        }

        private static function _objectToXML(arg1:*):String
        {
            var loc2:*=null;
            var loc1:*="<object>";
            var loc3:*=0;
            var loc4:*=arg1;
            for (loc2 in loc4)
            {
                loc1 = loc1 + ("<property id=\"" + loc2 + "\">" + _toXML(arg1[loc2]) + "</property>");
            }
            return loc1 + "</object>";
        }

        private static function _escapeXML(arg1:String):String
        {
            return arg1.replace(new RegExp("&", "g"), "&amp;").replace(new RegExp("<", "g"), "&lt;").replace(new RegExp(">", "g"), "&gt;").replace(new RegExp("\"", "g"), "&quot;").replace(new RegExp("\'", "g"), "&apos;");
        }

        private static function _toXML(arg1:*):String
        {
            var loc1:*=typeof arg1;
            if (loc1 == "string")
            {
                return "<string>" + _escapeXML(arg1) + "</string>";
            }
            if (loc1 == "undefined")
            {
                return "<undefined/>";
            }
            if (loc1 == "number")
            {
                return "<number>" + arg1 + "</number>";
            }
            if (arg1 == null)
            {
                return "<null/>";
            }
            if (loc1 == "boolean")
            {
                return arg1 ? "<true/>" : "<false/>";
            }
            if (arg1.hasOwnProperty("length"))
            {
                return _arrayToXML(arg1);
            }
            if (arg1 is Date)
            {
                return "<date>" + arg1.time + "</date>";
            }
            if (arg1 is Error && marshallExceptions)
            {
                return "<exception>" + arg1 + "</exception>";
            }
            if (loc1 == "object")
            {
                return _objectToXML(arg1);
            }
            return "<null/>";
        }

        private static function _objectToAS(arg1:Object):*
        {
            var loc2:*=null;
            var loc1:*={};
            var loc3:*=0;
            var loc4:*=arg1.property;
            for each (loc2 in loc4)
            {
                loc1[loc2.@id] = _toAS(loc2.children());
            }
            return loc1;
        }

        private static function _arrayToAS(arg1:Object):*
        {
            var loc2:*=null;
            var loc1:*=[];
            var loc3:*=0;
            var loc4:*=arg1.children();
            for each (loc2 in loc4)
            {
                loc1[loc2.@id] = _toAS(loc2.children());
            }
            return loc1;
        }

        private static function _toAS(arg1:Object):*
        {
            var loc1:*=arg1.name();
            if (loc1 == "number")
            {
                return Number(arg1.children());
            }
            if (loc1 == "string")
            {
                return String(arg1.children());
            }
            if (loc1 == "false")
            {
                return false;
            }
            if (loc1 == "true")
            {
                return true;
            }
            if (loc1 == "null")
            {
                return null;
            }
            if (loc1 == "undefined")
            {
                return undefined;
            }
            if (loc1 == "date")
            {
                return new Date(Number(arg1.children()));
            }
            if (loc1 == "object")
            {
                return _objectToAS(arg1);
            }
            if (loc1 == "array")
            {
                return _arrayToAS(arg1);
            }
            if (loc1 == "class")
            {
                return getDefinitionByName(String(arg1.children()));
            }
            if (loc1 == "exception" && marshallExceptions)
            {
                throw new Error(arg1.children());
            }
            return undefined;
        }

        private static function _argumentsToAS(arg1:*):Array
        {
            var loc2:*=null;
            var loc1:*=[];
            var loc3:*=0;
            var loc4:*=arg1.children();
            for each (loc2 in loc4)
            {
                loc1.push(_toAS(loc2));
            }
            return loc1;
        }

        private static function _arrayToJS(arg1:Array):String
        {
            var loc1:*="[";
            var loc2:*=0;
            while (loc2 < arg1.length)
            {
                if (loc2 != 0)
                {
                    loc1 = loc1 + ",";
                }
                loc1 = loc1 + _toJS(arg1[loc2]);
                ++loc2;
            }
            return loc1 + "]";
        }

        private static function _objectToJS(arg1:*):String
        {
            var loc1:*=_getPropNames(arg1);
            var loc2:*="({";
            var loc3:*=0;
            while (loc3 < loc1.length)
            {
                if (loc3 > 0)
                {
                    loc2 = loc2 + ",";
                }
                loc2 = loc2 + (loc1[loc3] + ":" + _toJS(arg1[loc1[loc3]]));
                ++loc3;
            }
            return loc2 + "})";
        }

        private static function _toJS(arg1:*):String
        {
            if (arg1 is Error && marshallExceptions)
            {
                return "throw \"" + arg1 + "\"";
            }
            if (typeof arg1 == "string")
            {
                return "\"" + arg1.replace(new RegExp("\\\"", "g"), "\\\"").replace(new RegExp("\\n", "g"), "\\n").replace(new RegExp("\\r", "g"), "\\r") + "\"";
            }
            if (arg1 === null)
            {
                return "null";
            }
            if (arg1 is Date)
            {
                return "new Date (" + arg1.time + ")";
            }
            if (typeof arg1 == "object")
            {
                if (arg1 is Array)
                {
                    return _arrayToJS(arg1);
                }
                return _objectToJS(arg1);
            }
            return String(arg1);
        }


        {
            marshallExceptions = false;
        }

        public static var marshallExceptions:Boolean=false;
    }
}