HybridGallery and ChatterBox updates

+<?php
+//error_reporting(E_ALL);
+
+/*
+Plugin Name:    Hybrid Gallery
+Version:        0.0.1
+Description:    Mix of photos and videos into one Media Gallery Plugin
+Author:         Kevin Burton
+Author URI:     http://www.gotenzing.com/
+*/
+
+
+
+class HybridGallery {
+
+    public static $defaults;
+    public static $WP_Settings;
+    public static $widget_dir;
+    public static $upload_dir;
+    
+    
+    const SETTINGS_NS   = 'hybridgallery';
+    const ADMIN_PAGE    = 'hybridgallery-settings';
+    const CAPABILITY    = 'hybridgallery_admin';
+    
+    public static function cInit() {
+        $role = get_role('administrator');
+        $role->add_cap(self::CAPABILITY);
+        
+        self::$widget_dir = TzTools::tools_url('./', __FILE__);
+        self::$upload_dir = dirname(__FILE__).'/uploads/';
+        
+        require('inc/config.php');
+        self::$defaults = $config;
+        
+        
+        $mArr = array();
+        foreach(self::$defaults as $option => $items) {
+            $mArr[$option] = $items[0];
+        }
+        
+        self::$WP_Settings = new WP_Option(self::SETTINGS_NS, $mArr);
+                        
+        ShortCodes::registerClass('HybridGallery_ShortCodes');
+        add_actions('HybridGallery_Actions');
+    }
+    
+    public static function adminDisplay() {
+        $defaults = self::$defaults;
+        require(dirname(__FILE__) . DIRECTORY_SEPARATOR . 'views' . DIRECTORY_SEPARATOR . 'admin' . DIRECTORY_SEPARATOR . 'settings.php');
+    }
+
+}
+
+class HybridGallery_Actions {
+
+    public static function init() {
+    
+        global $wpdb;
+        $wpdb->show_errors();
+        
+        register_post_type( 'gallery', array(
+              'label'           => __('Gallery Entries')
+            , 'public'          => true
+            , 'show_ui'         => false
+            , 'hierarchical'    => false
+            , 'supports'        => array('category')
+            ) );
+        register_taxonomy( 'hbGalleries', 'gallery', array( 'hierarchical' => true, 'label' => __('Galleries') ) );
+        
+        
+        // create a default gallery:
+        
+        $tablename = $wpdb->prefix . 'terms';
+        $query = $wpdb->get_row("SELECT * FROM `$tablename` WHERE `slug`='hg-gallery-general' LIMIT 1",'ARRAY_A');
+        
+        
+        
+        if ($wpdb->num_rows == 0) {
+            // doesn't exist, need to create default
+            $wpdb->query("INSERT INTO $tablename (name,slug) VALUES ('HG General Gallery','hg-gallery-general')");
+            $term_id = $wpdb->insert_id;
+            $tablename = $wpdb->prefix . 'term_taxonomy';
+            $wpdb->query("INSERT INTO $tablename (term_id,taxonomy,parent,count) VALUES ($term_id,'hbGalleries',0,0)");
+        }
+        
+    }
+    
+    public static function admin_menu() {
+        add_options_page('HybridGallery Settings', 'HybridGallery Settings', HybridGallery::CAPABILITY, HybridGallery::ADMIN_PAGE, Array('HybridGallery', 'adminDisplay'));
+    }
+    
+    public static function admin_init() {
+        register_setting(HybridGallery::SETTINGS_NS, HybridGallery::SETTINGS_NS);
+    }
+    
+    public static function wp_print_scripts() {
+        wp_enqueue_script('jquery');
+        wp_enqueue_script('jquery-form');
+        _enqueue_script('swfobject', TzTools::tools_url('assets/uploadify/swfobject.js', __FILE__), array('jquery'));
+        _enqueue_script('jquery-uploadify', TzTools::tools_url('assets/uploadify/jquery.uploadify.v2.1.0.js', __FILE__), array('jquery','swfobject'));
+    }
+
+}
+
+class HybridGallery_ShortCodes {
+    
+    public static $defaults;
+    
+    public static function HybridGallery($args = array(), $content, $tag) {
+    
+        $WP_Settings = new WP_Option(HybridGallery::SETTINGS_NS);
+        
+        foreach (HybridGallery::$defaults as $key => $val) {
+            if (isset($WP_Settings[$key])) {
+                self::$defaults[$key] = $WP_Settings[$key];
+            }
+        }
+
+        self::$defaults = shortcode_atts(self::$defaults, $args);
+                
+        ob_start();
+        include('views/gallery.php');
+        $output = ob_get_contents();
+        ob_end_clean();
+        return $output;
+    
+    }
+    
+}
+
+HybridGallery::cInit();
+
+?>
\ No newline at end of file

+/*
+START OF STATIC
+*/
+body, html {
+    margin:0px;
+    padding:0px;
+    height:100%;
+}
+
+body {
+    font: 12px/160% 'Trebuchet MS', Verdana, Arial, sans-serif;
+    color:#4D4D4D;
+}
+
+h1 {
+	color:#777;
+	margin: 0px 0 20px 0;
+	font-family: 'Tangerine', serif;
+    font-size: 48px;
+    text-shadow: 4px 4px 4px #aaa;
+    font-weight: normal;
+}
+h2 {
+	color:#777;
+	background-color: transparent;
+	font: normal 26px Georgia, Times, 'Times New Roman', serif;
+	margin: 0px 0 5px 0;
+}
+h3 {
+	color:#777;
+	background-color: transparent;
+	font: normal 20px Georgia, Times, 'Times New Roman', serif;
+	margin: 25px 0 5px 0;
+}
+
+h4 {
+	color:#777;
+	background-color: transparent;
+	font: normal 16px Georgia, Times, 'Times New Roman', serif;
+	margin: 0px 0 10px 0;
+}
+
+h5 {
+	color:#777;
+	background-color: transparent;
+	font: normal 16px Georgia, Times, 'Times New Roman', serif;
+	margin: 10px 0 5px 0;
+}
+
+
+
+hr { border:0; background-color: rgb(225,225,225); height:1px; margin: 5px 0px 10px 0px; clear: both;  }
+
+table { width: 100%; margin:0px; padding:0px; border: none; border-collapse: collapse; }
+table thead th {}
+table thead td {}
+table tbody th { text-align:left; color: #4D4D4D; padding: 2px 2px 2px 0px; width: 80px; }
+table tbody td { color: #999; padding: 2px 2px 2px 0px; }
+table a { font-size: 11px; }
+table th,td { font-size: 11px; }
+
+strong {  font-weight: bold; }
+
+a,a:link { color: #88c550; text-decoration: none; }
+a:hover,a:active {color: #4EAE08; text-decoration: none; }
+
+.clear { clear:both; }
+.left { float: left; }
+.right { float: right; }
+
+/*
+END OF STATIC
+*/
+
+#TzHybridGallery {}
+
+#TzHybridGallery_Control {
+    display:none;
+}
+
+.tabs {
+    float:left;
+    width:100%;
+    background:#fff;
+    font-size:93%;
+    line-height:normal;
+    border-bottom: 1px solid rgb(225,225,225);
+    margin-bottom:0px;
+}
+
+.tabs ul {
+    margin:0;
+    padding:10px 10px 0 10px;
+    list-style:none;
+}
+
+.tabs li {
+    display:inline;
+    margin:0;
+    padding:0;
+}
+
+.tabs .notes {
+    float:right;
+}
+
+.tabs a {
+    float:left;
+    background:url("../images/tableftB.gif") no-repeat left top;
+    margin:0;
+    padding:0 0 0 4px;
+    text-decoration:none;
+}
+
+.tabs a span {
+    float:left;
+    display:block;
+    background:url("../images/tabrightB.gif") no-repeat right top;
+    padding:5px 15px 4px 6px;
+    color:#666;
+}
+
+.tabs a:hover span,
+.tabs a.selected span {
+    color:#000;
+}
+
+.tabs a:hover,
+.tabs a.selected {
+    background-position:0% -42px;
+}
+
+.tabs a:hover span,
+.tabs a.selected span {
+    background-position:100% -42px;
+}
+
+.panels {
+    border:1px solid rgb(225,225,225);
+    border-top:none;
+    padding:10px;
+}
+
+.formSection {
+    float:left;
+    width:400px;
+}
+
+.UploadInformation {
+    float:right;
+    width: 300px;
+}
+
+.gallery-css-form {}
+.gallery-css-form p { clear: both; margin:0; padding:0; margin-bottom: 6px;}
+.gallery-css-form label { float: left; width: 120px; }
+.gallery-css-form input[type=text], .gallery-css-form textarea {
+    border:1px solid rgb(225,225,225);
+    padding:3px 4px;
+    width:250px;
+    font-size:11px;
+    font-family: arial,sans-serif;
+}
+
+.gallery-css-form input[type=submit] { border:1px solid #fff; background-color: #88c550; padding: 3px 8px; color:#fff;}
+.gallery-css-form p.submit-area { margin-top:15px;}
+
+#TzHybridGallery_Response {
+    border: 1px solid green;
+    background-color: #FFFFCC;
+    padding:10px;
+    color:green;
+    margin-top:10px;
+    display: none;
+}
+
+#TzHybridGallery_Viewport {
+    margin-top:10px;
+}
+
+.BoxError {
+    border:1px solid red;
+    background: pink url('../images/warning.png') bottom right no-repeat;
+    padding: 5px 10px 10px 10px;
+    color:red;
+    margin-bottom:10px;
+    font-size: 11px;
+    line-height:13px;
+}
+
+.BoxError p { margin-top:5px;}
+.BoxError p:first-child { margin-top:0px;}
+
+.BoxError legend { background: red; padding:3px 8px; color:#fff; font-size: 11px; }
+
+
+.BoxSuccess {
+    border:1px solid #88c550;
+    background: #FFFFCC;
+    padding: 5px 10px 10px 10px;
+    color:#88c550;
+    margin-bottom:10px;
+    font-size: 11px;
+    line-height:13px;
+}
+
+.BoxSuccess p { margin-top:5px;}
+.BoxSuccess p:first-child { margin-top:0px;}
+
+.BoxSuccess legend { background: #88c550; padding:3px 8px; color:#fff; font-size: 11px; }
+
+
+
+
+.image-selected-name,.subtext,.video-selected-name { color: #ccc;}
+
+#TzHybridGallery_Header {
+    margin-bottom:10px;
+}
+
+textarea {
+    resize: none;
+}
\ No newline at end of file

+var errors = new Array();
+
+function grabGalleryFeed() {
+    var viewport = jQuery('#TzHybridGallery_Viewport');
+    viewport.html('Loading gallery...');
+    
+    jQuery.ajax({
+        url:        widget_dir + 'inc/viewer.php'
+      , data:       global_settings
+      , type:       'post'
+      , dataType:   'json'
+      , success:    renderGallery
+    });
+    
+}
+
+function renderGallery(data) {
+    var viewport = jQuery('#TzHybridGallery_Viewport');
+    
+    if(data.length < 1) {
+        viewport.html("No gallery posts.");
+    } else {
+        var output = jQuery('<div></div>');
+        
+        for(i=0; i < data.length; i++) {
+            var item = jQuery('<div style="margin-bottom:15px;"></div>');
+            item.append('<div><strong>Title:</strong> '+data[i].post_title+'</div>');
+            item.append('<div><strong>Description:</strong> '+data[i].post_content+'</div>');
+            item.append('<div><strong>Gallery Type:</strong> '+data[i].gallery_type+'</div>');
+            item.append('<div><strong>File Name/URL:</strong> '+data[i].filename+'</div>');
+            item.append('<div><strong>Link Type:</strong> '+data[i].link_type+'</div>');
+            item.append('<div><strong>Added By:</strong> '+data[i].author_name+'</div>');
+            item.append('<div><strong>On:</strong> '+data[i].human_date+'</div>');
+            
+            var thumb = "";
+            
+            if (data[i].link_type == "linked" && data[i].gallery_type == "image") {
+                thumb = data[i].filename;
+            } else if (data[i].link_type == "linked" && data[i].gallery_type == "video") {
+                thumb = data[i].thumbnail;
+            } else {
+                thumb = widget_dir + "uploads/" + data[i].filename;
+            }
+            
+            item.append('<div><strong>Thumbnail:</strong><img src="'+thumb+'" width="50" /></div>');
+            item.append('<div><strong>Status:</strong> '+data[i].status+'</div>');
+            
+            output.append(item);
+        }
+        
+        viewport.html(output);
+    }
+    
+}
+
+function pushError(msg) {
+    errors.push(msg);
+}
+
+function showErrors() {
+    var el = jQuery("#TzImageFormErrors");
+    var errorContainer = jQuery(".errors",el);
+    errorContainer.empty();
+    
+    for(var i=0; i < errors.length; i++) {
+        errorContainer.append("<p>"+errors[i]+"</p>");
+    }
+    errors.length = 0;
+    el.show();
+}
+
+function showSuccess(msg) {
+    var el = jQuery("#TzImageFormSuccess");
+    var responseContainer = jQuery(".response",el);
+    responseContainer.empty().html(msg);
+    el.show();
+    
+    setTimeout("hideSuccess()",3000);
+}
+
+function hideSuccess() {
+    var el = jQuery("#TzImageFormSuccess");
+    el.fadeOut();
+}
+
+function hideErrors() {
+    var el = jQuery("#TzImageFormErrors");
+    el.hide();
+}
+
+function checkImageForm(formData,jqForm, options) {
+    
+    
+    var formElement = jqForm[0];
+    
+    if (formElement.title.value == "") { pushError("The title field is required"); }
+    if (formElement.description.value == "") { pushError("The description field is required"); }
+    if (formElement.uploaded_image_filename.value == "" && formElement.imageLinked.value == "") { pushError("Please link or upload an image."); }
+    
+    if (errors.length > 0) {
+        showErrors();
+        return false;
+    } else {
+        hideErrors();
+        return true;
+    }
+}
+
+function imageFormComplete(resp, statusText, xhr, $form) {
+    if(resp.status == "error") {
+        errors.length = 0;
+        pushError(resp.details);
+        showErrors();
+    } else {
+        showSuccess(resp.details);
+    }
+    
+    jQuery('#uploaded_image_filename').val('');
+    jQuery('.image-selected-name').empty();
+    
+    document.image_form.imageLinked.disabled = false;
+    jQuery('#TzHybridGallery_Control').slideUp();
+}
+
+function checkVideoForm(formData,jqForm, options) {
+    
+    var formElement = jqForm[0];
+    if (formElement.videoLinked.value == "" && formElement.uploaded_video_filename.value == "") {
+        pushError("Please link or upload a video");
+    } else {
+        if (formElement.uploaded_video_filename.value != "") {
+            // it's an uploaded video
+            if (formElement.video_title.value=="" || formElement.video_description.value=="") {
+                pushError("Please enter a title and description for your video.");
+            }
+            
+        } else {
+            // video Linked....
+            
+        }
+    }
+    
+    if (errors.length > 0) {
+        showErrors();
+        return false;
+    } else {
+        hideErrors();
+        return true;
+    }
+    
+}
+
+function videoFormComplete(resp, statusText, xhr, $form) {
+    if(resp.status == "error") {
+        errors.length = 0;
+        pushError(resp.details);
+        showErrors();
+    } else {
+        showSuccess(resp.details);
+    }
+    jQuery('.video-selected-name').empty();
+    jQuery('#uploaded_video_filename').val('');
+    
+    document.video_form.videoLinked.disabled = false;
+    jQuery('#TzHybridGallery_Control').slideUp();
+}
+
+function showResponse(message) {
+    jQuery('#TzHybridGallery_Response').html(message).fadeIn();
+}
+
+
+jQuery(document).ready(function($) {
+   
+    grabGalleryFeed();
+   
+    $('.form-cancel').live('click',function() {
+        hideErrors();
+        jQuery('#TzHybridGallery_Control').slideUp();
+    });
+    
+    
+   
+    /* ADD NEW SECTION -------------------------------------------------------------- */ 
+    $('#TzHybridGallery_Header').delegate('a#TzAddNewBtn','click',function() {
+        $('#TzHybridGallery_Control').show();
+        var tabs            = [];
+        var tabContainers   = [];
+        $('.tabs ul li a').each(function() {
+            if(this.pathname == window.location.pathname) {
+                tabs.push(this);
+                tabContainers.push($(this.hash).get(0));
+            }
+        });
+        $(tabs).click(function() {
+            $(tabContainers).hide().filter(this.hash).show();
+            $(tabs).removeClass('selected');
+            $(this).addClass('selected');
+            return false;
+        }).filter(':first').click();
+        
+        
+        
+        $('#image_form').ajaxForm({
+            beforeSubmit:   checkImageForm
+          , success:        imageFormComplete
+          , url:            widget_dir + 'inc/forms.php'
+          , data:           { 'form_type' : 'image-form', 'gallery' : global_settings.default_gallery, 'approval' : global_settings.image_approval }
+          , type:           'post'
+          , dataType:        'json'
+          , clearForm:      true
+          , resetForm:      true 
+        });
+        
+        
+        $('#video_form').ajaxForm({
+            beforeSubmit:   checkVideoForm
+          , success:        videoFormComplete
+          , url:            widget_dir + 'inc/forms.php'
+          , data:           { 'form_type' : 'video-form', 'gallery' : global_settings.default_gallery, 'approval' : global_settings.video_approval }
+          , type:           'post'
+          , dataType:       'json'
+          , clearForm:      true
+          , resetForm:      true
+        });
+        
+        
+        
+        
+    });
+    /* ------------------------------------------------------------------------------ */
+    
+    $('#imageInput').uploadify({
+        'uploader'  : widget_dir + 'assets/uploadify/uploadify.swf'
+      , 'script'    : widget_dir + 'assets/uploadify/uploadify.php'
+      , 'cancelImg' : widget_dir + 'assets/uploadify/cancel.png'
+      , 'auto'      : true
+      , 'folder'    : upload_dir
+      , 'buttonImg' : widget_dir + 'assets/uploadify/upload_btn.png'
+      , 'height'    : 26
+      , 'width'     : 76
+      , 'sizeLimit' : (2*1000000)
+      , 'fileDesc'  : "Images Only!"
+      , 'fileExt'   : "*.gif;*.jpg;*.png"
+      , onComplete  : function(e,q,fileObj) {
+                        $('#uploaded_image_filename').val(fileObj.name);
+                        $('.image-selected-name').css('color','#4D4D4D').html("<img src='"+widget_dir+"assets/images/accept.png' align='absmiddle' />&nbsp;"+fileObj.name+" uploaded.");
+                        document.image_form.imageLinked.value = "";
+                        document.image_form.imageLinked.disabled = true;
+                        return true;
+                      }
+    });
+        
+    $('#videoInput').uploadify({
+        'uploader'  : widget_dir + 'assets/uploadify/uploadify.swf'
+      , 'script'    : widget_dir + 'assets/uploadify/uploadify.php'
+      , 'cancelImg' : widget_dir + 'assets/uploadify/cancel.png'
+      , 'auto'      : true
+      , 'folder'    : widget_dir + 'uploads/'
+      , 'buttonImg' : widget_dir + 'assets/uploadify/upload_btn.png'
+      , 'height'    : 26
+      , 'width'     : 76
+      , 'sizeLimit' : (20000*1000000)
+      , 'fileDesc'  : "Proper Video Formats Only"
+      , 'fileExt'   : '*.wmv;*.3gp;*.avi;*.mov;*.mp4;*.mpeg;*.mpg;*.flv;*.mkv;*.gif'
+      , onComplete  : function(e,q,fileObj) {
+                        $('#uploaded_video_filename').val(fileObj.name);
+                        $('.video-selected-name').css('color','#4D4D4D').html("<img src='"+widget_dir+"assets/images/accept.png' align='absmiddle' />&nbsp;"+fileObj.name+" uploaded.");
+                        document.video_form.videoLinked.value = "";
+                        document.video_form.videoLinked.disabled = true;
+                        return true;
+                      }
+    });
+    
+});
\ No newline at end of file

+<?php
+/*
+Uploadify v2.1.0
+Release Date: August 24, 2009
+
+Copyright (c) 2009 Ronnie Garcia, Travis Nickels
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in
+all copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
+THE SOFTWARE.
+*/
+$fileArray = array();
+foreach ($_POST as $key => $value) {
+	if ($key != 'folder') {
+		if (file_exists($_SERVER['DOCUMENT_ROOT'] . $_POST['folder'] . '/' . $value)) {
+			$fileArray[$key] = $value;
+		}
+	}
+}
+echo json_encode($fileArray);
+?>
\ No newline at end of file

+/*
+  Copyright (c) 2008, Adobe Systems Incorporated
+  All rights reserved.
+
+  Redistribution and use in source and binary forms, with or without 
+  modification, are permitted provided that the following conditions are
+  met:
+
+  * Redistributions of source code must retain the above copyright notice, 
+    this list of conditions and the following disclaimer.
+  
+  * Redistributions in binary form must reproduce the above copyright
+    notice, this list of conditions and the following disclaimer in the 
+    documentation and/or other materials provided with the distribution.
+  
+  * Neither the name of Adobe Systems Incorporated nor the names of its 
+    contributors may be used to endorse or promote products derived from 
+    this software without specific prior written permission.
+
+  THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS
+  IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO,
+  THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR
+  PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT OWNER OR 
+  CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL,
+  EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO,
+  PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR
+  PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF
+  LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING
+  NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS
+  SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+*/
+
+package com.adobe.air.logging
+{
+	import mx.logging.AbstractTarget;
+	import flash.filesystem.File;
+	import flash.filesystem.FileStream;
+	import flash.filesystem.FileMode;
+	import mx.logging.LogEvent;
+	import flash.system.System;
+	import flash.system.Capabilities;
+	import mx.logging.targets.LineFormattedTarget;
+	import mx.core.mx_internal;
+	
+	use namespace mx_internal;
+
+	/**
+	 * An Adobe AIR only class that provides a log target for the Flex logging
+	 * framework, that logs files to a file on the user's system.
+	 * 
+	 * This class will only work when running within Adobe AIR>
+	 */
+	public class FileTarget extends LineFormattedTarget
+	{
+		private const DEFAULT_LOG_PATH:String = "app-storage:/application.log";
+		
+		private var log:File;
+		
+		public function FileTarget(logFile:File = null)
+		{
+			if(logFile != null)
+			{
+				log = logFile;
+			}
+			else
+			{
+				log = new File(DEFAULT_LOG_PATH);
+			}
+		}
+		
+		public function get logURI():String
+		{
+			return log.url;
+		}
+		
+		mx_internal override function internalLog(message:String):void
+	    {
+			write(message);
+	    }		
+		
+		private function write(msg:String):void
+		{		
+			var fs:FileStream = new FileStream();
+				fs.open(log, FileMode.APPEND);
+				fs.writeUTFBytes(msg + "\n");
+				fs.close();
+		}	
+		
+		public function clear():void
+		{
+			var fs:FileStream = new FileStream();
+				fs.open(log, FileMode.WRITE);
+				fs.writeUTFBytes("");
+				fs.close();			
+		}
+		
+	}
+}
\ No newline at end of file

+/*
+  Copyright (c) 2008, Adobe Systems Incorporated
+  All rights reserved.
+
+  Redistribution and use in source and binary forms, with or without 
+  modification, are permitted provided that the following conditions are
+  met:
+
+  * Redistributions of source code must retain the above copyright notice, 
+    this list of conditions and the following disclaimer.
+  
+  * Redistributions in binary form must reproduce the above copyright
+    notice, this list of conditions and the following disclaimer in the 
+    documentation and/or other materials provided with the distribution.
+  
+  * Neither the name of Adobe Systems Incorporated nor the names of its 
+    contributors may be used to endorse or promote products derived from 
+    this software without specific prior written permission.
+
+  THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS
+  IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO,
+  THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR
+  PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT OWNER OR 
+  CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL,
+  EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO,
+  PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR
+  PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF
+  LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING
+  NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS
+  SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+*/
+
+package com.adobe.crypto {
+	import flash.utils.ByteArray;
+	import flash.utils.Endian;
+	import flash.utils.describeType;
+	/**
+	 * Keyed-Hashing for Message Authentication
+	 * Implementation based on algorithm description at 
+	 * http://www.faqs.org/rfcs/rfc2104.html
+	 */
+	public class HMAC 
+	{
+		/**
+		 * Performs the HMAC hash algorithm using byte arrays.
+		 *
+		 * @param secret The secret key
+		 * @param message The message to hash
+		 * @param algorithm Hash object to use
+		 * @return A string containing the hash value of message
+		 * @langversion ActionScript 3.0
+		 * @playerversion Flash 8.5
+		 * @tiptext
+		 */
+		public static function hash( secret:String, message:String, algorithm:Object = null ):String
+		{
+			var text:ByteArray = new ByteArray();
+			var k_secret:ByteArray = new ByteArray();
+			
+			text.writeUTFBytes(message);
+			k_secret.writeUTFBytes(secret);
+			
+			return hashBytes(k_secret, text, algorithm);
+		}
+		
+		/**
+		 * Performs the HMAC hash algorithm using string.
+		 *
+		 * @param secret The secret key
+		 * @param message The message to hash
+		 * @param algorithm Hash object to use
+		 * @return A string containing the hash value of message
+		 * @langversion ActionScript 3.0
+		 * @playerversion Flash 8.5
+		 * @tiptext
+		 */
+		public static function hashBytes( secret:ByteArray, message:ByteArray, algorithm:Object = null ):String
+		{
+			var ipad:ByteArray = new ByteArray();
+			var opad:ByteArray = new ByteArray();
+			var endian:String = Endian.BIG_ENDIAN;
+			
+			if(algorithm == null){
+				algorithm = MD5;
+			}
+			
+			if ( describeType(algorithm).@name.toString() == "com.adobe.crypto::MD5" ) {
+				endian = Endian.LITTLE_ENDIAN;
+			}
+			
+			if ( secret.length > 64 ) {
+				algorithm.hashBytes(secret);
+				secret = new ByteArray();
+				secret.endian = endian;
+				
+				while ( algorithm.digest.bytesAvailable != 0 ) {
+					secret.writeInt(algorithm.digest.readInt());
+				}
+			}
+
+			secret.length = 64
+			secret.position = 0;
+			for ( var x:int = 0; x < 64; x++ ) {
+				var byte:int = secret.readByte();
+				ipad.writeByte(0x36 ^ byte);
+				opad.writeByte(0x5c ^ byte);
+			}
+			
+			ipad.writeBytes(message);
+			algorithm.hashBytes(ipad);
+			var tmp:ByteArray = new ByteArray();
+			tmp.endian = endian;	
+			
+			while ( algorithm.digest.bytesAvailable != 0 ) {
+				tmp.writeInt(algorithm.digest.readInt());
+			}
+			tmp.position = 0;
+			
+			while ( tmp.bytesAvailable != 0 ) {
+				opad.writeByte(tmp.readUnsignedByte());
+			}
+			return algorithm.hashBytes( opad );
+		}
+		
+	}
+	
+}

+/*
+  Copyright (c) 2008, Adobe Systems Incorporated
+  All rights reserved.
+
+  Redistribution and use in source and binary forms, with or without 
+  modification, are permitted provided that the following conditions are
+  met:
+
+  * Redistributions of source code must retain the above copyright notice, 
+    this list of conditions and the following disclaimer.
+  
+  * Redistributions in binary form must reproduce the above copyright
+    notice, this list of conditions and the following disclaimer in the 
+    documentation and/or other materials provided with the distribution.
+  
+  * Neither the name of Adobe Systems Incorporated nor the names of its 
+    contributors may be used to endorse or promote products derived from 
+    this software without specific prior written permission.
+
+  THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS
+  IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO,
+  THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR
+  PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT OWNER OR 
+  CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL,
+  EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO,
+  PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR
+  PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF
+  LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING
+  NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS
+  SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+*/
+
+package com.adobe.crypto
+{
+	import com.adobe.utils.IntUtil;
+	import flash.utils.ByteArray;
+	import mx.utils.Base64Encoder;
+	
+	/**
+	 *  US Secure Hash Algorithm 1 (SHA1)
+	 *
+	 *  Implementation based on algorithm description at 
+	 *  http://www.faqs.org/rfcs/rfc3174.html
+	 */
+	public class SHA1
+	{
+		public static var digest:ByteArray;
+		
+		/**
+		 *  Performs the SHA1 hash algorithm on a string.
+		 *
+		 *  @param s		The string to hash
+		 *  @return			A string containing the hash value of s
+		 *  @langversion	ActionScript 3.0
+		 *  @playerversion	9.0
+		 *  @tiptext
+		 */
+		public static function hash( s:String ):String
+		{
+			var blocks:Array = createBlocksFromString( s );
+			var byteArray:ByteArray = hashBlocks( blocks );
+			
+			return IntUtil.toHex( byteArray.readInt(), true )
+					+ IntUtil.toHex( byteArray.readInt(), true )
+					+ IntUtil.toHex( byteArray.readInt(), true )
+					+ IntUtil.toHex( byteArray.readInt(), true )
+					+ IntUtil.toHex( byteArray.readInt(), true );
+		}
+		
+		/**
+		 *  Performs the SHA1 hash algorithm on a ByteArray.
+		 *
+		 *  @param data		The ByteArray data to hash
+		 *  @return			A string containing the hash value of data
+		 *  @langversion	ActionScript 3.0
+		 *  @playerversion	9.0
+		 */
+		public static function hashBytes( data:ByteArray ):String
+		{
+			var blocks:Array = SHA1.createBlocksFromByteArray( data );
+			var byteArray:ByteArray = hashBlocks(blocks);
+			
+			return IntUtil.toHex( byteArray.readInt(), true )
+					+ IntUtil.toHex( byteArray.readInt(), true )
+					+ IntUtil.toHex( byteArray.readInt(), true )
+					+ IntUtil.toHex( byteArray.readInt(), true )
+					+ IntUtil.toHex( byteArray.readInt(), true );
+		}
+		
+		/**
+		 *  Performs the SHA1 hash algorithm on a string, then does
+		 *  Base64 encoding on the result.
+		 *
+		 *  @param s		The string to hash
+		 *  @return			The base64 encoded hash value of s
+		 *  @langversion	ActionScript 3.0
+		 *  @playerversion	9.0
+		 *  @tiptext
+		 */
+		public static function hashToBase64( s:String ):String
+		{
+			var blocks:Array = SHA1.createBlocksFromString( s );
+			var byteArray:ByteArray = hashBlocks(blocks);
+
+			// ByteArray.toString() returns the contents as a UTF-8 string,
+			// which we can't use because certain byte sequences might trigger
+			// a UTF-8 conversion.  Instead, we convert the bytes to characters
+			// one by one.
+			var charsInByteArray:String = "";
+			byteArray.position = 0;
+			for (var j:int = 0; j < byteArray.length; j++)
+			{
+				var byte:uint = byteArray.readUnsignedByte();
+				charsInByteArray += String.fromCharCode(byte);
+			}
+
+			var encoder:Base64Encoder = new Base64Encoder();
+			encoder.encode(charsInByteArray);
+			return encoder.flush();
+		}
+		
+		private static function hashBlocks( blocks:Array ):ByteArray
+		{
+			// initialize the h's
+			var h0:int = 0x67452301;
+			var h1:int = 0xefcdab89;
+			var h2:int = 0x98badcfe;
+			var h3:int = 0x10325476;
+			var h4:int = 0xc3d2e1f0;
+			
+			var len:int = blocks.length;
+			var w:Array = new Array( 80 );
+			
+			// loop over all of the blocks
+			for ( var i:int = 0; i < len; i += 16 ) {
+			
+				// 6.1.c
+				var a:int = h0;
+				var b:int = h1;
+				var c:int = h2;
+				var d:int = h3;
+				var e:int = h4;
+				
+				// 80 steps to process each block
+				// TODO: unroll for faster execution, or 4 loops of
+				// 20 each to avoid the k and f function calls
+				for ( var t:int = 0; t < 80; t++ ) {
+					
+					if ( t < 16 ) {
+						// 6.1.a
+						w[ t ] = blocks[ i + t ];
+					} else {
+						// 6.1.b
+						w[ t ] = IntUtil.rol( w[ t - 3 ] ^ w[ t - 8 ] ^ w[ t - 14 ] ^ w[ t - 16 ], 1 );
+					}
+					
+					// 6.1.d
+					var temp:int = IntUtil.rol( a, 5 ) + f( t, b, c, d ) + e + int( w[ t ] ) + k( t );
+					
+					e = d;
+					d = c;
+					c = IntUtil.rol( b, 30 );
+					b = a;
+					a = temp;
+				}
+				
+				// 6.1.e
+				h0 += a;
+				h1 += b;
+				h2 += c;
+				h3 += d;
+				h4 += e;		
+			}
+			
+			var byteArray:ByteArray = new ByteArray();
+			byteArray.writeInt(h0);
+			byteArray.writeInt(h1);
+			byteArray.writeInt(h2);
+			byteArray.writeInt(h3);
+			byteArray.writeInt(h4);
+			byteArray.position = 0;
+			
+			digest = new ByteArray();
+			digest.writeBytes(byteArray);
+			digest.position = 0;
+			return byteArray;
+		}
+
+		/**
+		 *  Performs the logical function based on t
+		 */
+		private static function f( t:int, b:int, c:int, d:int ):int {
+			if ( t < 20 ) {
+				return ( b & c ) | ( ~b & d );
+			} else if ( t < 40 ) {
+				return b ^ c ^ d;
+			} else if ( t < 60 ) {
+				return ( b & c ) | ( b & d ) | ( c & d );
+			}
+			return b ^ c ^ d;
+		}
+		
+		/**
+		 *  Determines the constant value based on t
+		 */
+		private static function k( t:int ):int {
+			if ( t < 20 ) {
+				return 0x5a827999;
+			} else if ( t < 40 ) {
+				return 0x6ed9eba1;
+			} else if ( t < 60 ) {
+				return 0x8f1bbcdc;
+			}
+			return 0xca62c1d6;
+		}
+					
+		/**
+		 *  Converts a ByteArray to a sequence of 16-word blocks
+		 *  that we'll do the processing on.  Appends padding
+		 *  and length in the process.
+		 *
+		 *  @param data		The data to split into blocks
+		 *  @return			An array containing the blocks into which data was split
+		 */
+		private static function createBlocksFromByteArray( data:ByteArray ):Array
+		{
+			var oldPosition:int = data.position;
+			data.position = 0;
+			
+			var blocks:Array = new Array();
+			var len:int = data.length * 8;
+			var mask:int = 0xFF; // ignore hi byte of characters > 0xFF
+			for( var i:int = 0; i < len; i += 8 )
+			{
+				blocks[ i >> 5 ] |= ( data.readByte() & mask ) << ( 24 - i % 32 );
+			}
+			
+			// append padding and length
+			blocks[ len >> 5 ] |= 0x80 << ( 24 - len % 32 );
+			blocks[ ( ( ( len + 64 ) >> 9 ) << 4 ) + 15 ] = len;
+			
+			data.position = oldPosition;
+			
+			return blocks;
+		}
+					
+		/**
+		 *  Converts a string to a sequence of 16-word blocks
+		 *  that we'll do the processing on.  Appends padding
+		 *  and length in the process.
+		 *
+		 *  @param s	The string to split into blocks
+		 *  @return		An array containing the blocks that s was split into.
+		 */
+		private static function createBlocksFromString( s:String ):Array
+		{
+			var blocks:Array = new Array();
+			var len:int = s.length * 8;
+			var mask:int = 0xFF; // ignore hi byte of characters > 0xFF
+			for( var i:int = 0; i < len; i += 8 ) {
+				blocks[ i >> 5 ] |= ( s.charCodeAt( i / 8 ) & mask ) << ( 24 - i % 32 );
+			}
+			
+			// append padding and length
+			blocks[ len >> 5 ] |= 0x80 << ( 24 - len % 32 );
+			blocks[ ( ( ( len + 64 ) >> 9 ) << 4 ) + 15 ] = len;
+			return blocks;
+		}
+		
+	}
+}

+/*
+  Copyright (c) 2008, Adobe Systems Incorporated
+  All rights reserved.
+
+  Redistribution and use in source and binary forms, with or without 
+  modification, are permitted provided that the following conditions are
+  met:
+
+  * Redistributions of source code must retain the above copyright notice, 
+    this list of conditions and the following disclaimer.
+  
+  * Redistributions in binary form must reproduce the above copyright
+    notice, this list of conditions and the following disclaimer in the 
+    documentation and/or other materials provided with the distribution.
+  
+  * Neither the name of Adobe Systems Incorporated nor the names of its 
+    contributors may be used to endorse or promote products derived from 
+    this software without specific prior written permission.
+
+  THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS
+  IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO,
+  THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR
+  PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT OWNER OR 
+  CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL,
+  EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO,
+  PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR
+  PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF
+  LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING
+  NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS
+  SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+*/
+
+package com.adobe.crypto
+{
+	import com.adobe.utils.IntUtil;
+	import flash.utils.ByteArray;
+	import mx.utils.Base64Encoder;
+	
+	/**
+	 * The SHA-224 algorithm
+	 * 
+	 * @see http://csrc.nist.gov/publications/fips/fips180-2/fips180-2withchangenotice.pdf
+	 */
+	public class SHA224
+	{
+		public static var digest:ByteArray;
+		
+		/**
+		 *  Performs the SHA224 hash algorithm on a string.
+		 *
+		 *  @param s		The string to hash
+		 *  @return			A string containing the hash value of s
+		 *  @langversion	ActionScript 3.0
+		 *  @playerversion	9.0
+		 *  @tiptext
+		 */
+		public static function hash( s:String ):String {
+			var blocks:Array = createBlocksFromString( s );
+			var byteArray:ByteArray = hashBlocks( blocks );
+			return IntUtil.toHex( byteArray.readInt(), true )
+					+ IntUtil.toHex( byteArray.readInt(), true )
+					+ IntUtil.toHex( byteArray.readInt(), true )
+					+ IntUtil.toHex( byteArray.readInt(), true )
+					+ IntUtil.toHex( byteArray.readInt(), true )
+					+ IntUtil.toHex( byteArray.readInt(), true )
+					+ IntUtil.toHex( byteArray.readInt(), true );
+		}
+		
+		/**
+		 *  Performs the SHA224 hash algorithm on a ByteArray.
+		 *
+		 *  @param data		The ByteArray data to hash
+		 *  @return			A string containing the hash value of data
+		 *  @langversion	ActionScript 3.0
+		 *  @playerversion	9.0
+		 */
+		public static function hashBytes( data:ByteArray ):String
+		{
+			var blocks:Array = createBlocksFromByteArray( data );
+			var byteArray:ByteArray = hashBlocks(blocks);
+			return IntUtil.toHex( byteArray.readInt(), true )
+					+ IntUtil.toHex( byteArray.readInt(), true )
+					+ IntUtil.toHex( byteArray.readInt(), true )
+					+ IntUtil.toHex( byteArray.readInt(), true )
+					+ IntUtil.toHex( byteArray.readInt(), true )
+					+ IntUtil.toHex( byteArray.readInt(), true )
+					+ IntUtil.toHex( byteArray.readInt(), true );
+		}
+		
+		/**
+		 *  Performs the SHA224 hash algorithm on a string, then does
+		 *  Base64 encoding on the result.
+		 *
+		 *  @param s		The string to hash
+		 *  @return			The base64 encoded hash value of s
+		 *  @langversion	ActionScript 3.0
+		 *  @playerversion	9.0
+		 *  @tiptext
+		 */
+		public static function hashToBase64( s:String ):String
+		{
+			var blocks:Array = createBlocksFromString( s );
+			var byteArray:ByteArray = hashBlocks(blocks);
+
+			// ByteArray.toString() returns the contents as a UTF-8 string,
+			// which we can't use because certain byte sequences might trigger
+			// a UTF-8 conversion.  Instead, we convert the bytes to characters
+			// one by one.
+			var charsInByteArray:String = "";
+			byteArray.position = 0;
+			for (var j:int = 0; j < byteArray.length; j++)
+			{
+				var byte:uint = byteArray.readUnsignedByte();
+				charsInByteArray += String.fromCharCode(byte);
+			}
+
+			var encoder:Base64Encoder = new Base64Encoder();
+			encoder.encode(charsInByteArray);
+			return encoder.flush();
+		}
+		
+		private static function hashBlocks( blocks:Array ):ByteArray {
+			var h0:int = 0xc1059ed8;
+			var h1:int = 0x367cd507;
+			var h2:int = 0x3070dd17;
+			var h3:int = 0xf70e5939;
+			var h4:int = 0xffc00b31;
+			var h5:int = 0x68581511;
+			var h6:int = 0x64f98fa7;
+			var h7:int = 0xbefa4fa4;
+			
+			var k:Array = new Array(0x428a2f98, 0x71374491, 0xb5c0fbcf, 0xe9b5dba5, 0x3956c25b, 0x59f111f1, 0x923f82a4, 0xab1c5ed5, 0xd807aa98, 0x12835b01, 0x243185be, 0x550c7dc3, 0x72be5d74, 0x80deb1fe, 0x9bdc06a7, 0xc19bf174, 0xe49b69c1, 0xefbe4786, 0x0fc19dc6, 0x240ca1cc, 0x2de92c6f, 0x4a7484aa, 0x5cb0a9dc, 0x76f988da, 0x983e5152, 0xa831c66d, 0xb00327c8, 0xbf597fc7, 0xc6e00bf3, 0xd5a79147, 0x06ca6351, 0x14292967, 0x27b70a85, 0x2e1b2138, 0x4d2c6dfc, 0x53380d13, 0x650a7354, 0x766a0abb, 0x81c2c92e, 0x92722c85, 0xa2bfe8a1, 0xa81a664b, 0xc24b8b70, 0xc76c51a3, 0xd192e819, 0xd6990624, 0xf40e3585, 0x106aa070, 0x19a4c116, 0x1e376c08, 0x2748774c, 0x34b0bcb5, 0x391c0cb3, 0x4ed8aa4a, 0x5b9cca4f, 0x682e6ff3, 0x748f82ee, 0x78a5636f, 0x84c87814, 0x8cc70208, 0x90befffa, 0xa4506ceb, 0xbef9a3f7, 0xc67178f2);
+			
+			var len:int = blocks.length;
+			var w:Array = new Array();
+			
+			// loop over all of the blocks
+			for ( var i:int = 0; i < len; i += 16 ) {
+				
+				var a:int = h0;
+				var b:int = h1;
+				var c:int = h2;
+				var d:int = h3;
+				var e:int = h4;
+				var f:int = h5;
+				var g:int = h6;
+				var h:int = h7;
+				
+				for(var t:int = 0; t < 64; t++) {
+					
+					if ( t < 16 ) {
+						w[t] = blocks[ i + t ];
+						if(isNaN(w[t])) { w[t] = 0; }
+					} else {
+						var ws0:int = IntUtil.ror(w[t-15], 7) ^ IntUtil.ror(w[t-15], 18) ^ (w[t-15] >>> 3);
+						var ws1:int = IntUtil.ror(w[t-2], 17) ^ IntUtil.ror(w[t-2], 19) ^ (w[t-2] >>> 10);
+						w[t] = w[t-16] + ws0 + w[t-7] + ws1;
+					}
+					
+					var s0:int = IntUtil.ror(a, 2) ^ IntUtil.ror(a, 13) ^ IntUtil.ror(a, 22);
+					var maj:int = (a & b) ^ (a & c) ^ (b & c);
+					var t2:int = s0 + maj;
+					var s1:int = IntUtil.ror(e, 6) ^ IntUtil.ror(e, 11) ^ IntUtil.ror(e, 25);
+					var ch:int = (e & f) ^ ((~e) & g);
+					var t1:int = h + s1 + ch + k[t] + w[t];
+					
+					h = g;
+					g = f;
+					f = e;
+					e = d + t1;
+					d = c;
+					c = b;
+					b = a;
+					a = t1 + t2;
+				}
+					
+				//Add this chunk's hash to result so far:
+				h0 += a;
+				h1 += b;
+				h2 += c;
+				h3 += d;
+				h4 += e;
+				h5 += f;
+				h6 += g;
+				h7 += h;
+			}
+			
+			var byteArray:ByteArray = new ByteArray();
+			byteArray.writeInt(h0);
+			byteArray.writeInt(h1);
+			byteArray.writeInt(h2);
+			byteArray.writeInt(h3);
+			byteArray.writeInt(h4);
+			byteArray.writeInt(h5);
+			byteArray.writeInt(h6);
+			byteArray.position = 0;
+			
+			digest = new ByteArray();
+			digest.writeBytes(byteArray);
+			digest.position = 0;
+			return byteArray;
+		}
+		
+		/**
+		 *  Converts a ByteArray to a sequence of 16-word blocks
+		 *  that we'll do the processing on.  Appends padding
+		 *  and length in the process.
+		 *
+		 *  @param data		The data to split into blocks
+		 *  @return			An array containing the blocks into which data was split
+		 */
+		private static function createBlocksFromByteArray( data:ByteArray ):Array
+		{
+			var oldPosition:int = data.position;
+			data.position = 0;
+			
+			var blocks:Array = new Array();
+			var len:int = data.length * 8;
+			var mask:int = 0xFF; // ignore hi byte of characters > 0xFF
+			for( var i:int = 0; i < len; i += 8 )
+			{
+				blocks[ i >> 5 ] |= ( data.readByte() & mask ) << ( 24 - i % 32 );
+			}
+			
+			// append padding and length
+			blocks[ len >> 5 ] |= 0x80 << ( 24 - len % 32 );
+			blocks[ ( ( ( len + 64 ) >> 9 ) << 4 ) + 15 ] = len;
+			
+			data.position = oldPosition;
+			
+			return blocks;
+		}
+					
+		/**
+		 *  Converts a string to a sequence of 16-word blocks
+		 *  that we'll do the processing on.  Appends padding
+		 *  and length in the process.
+		 *
+		 *  @param s	The string to split into blocks
+		 *  @return		An array containing the blocks that s was split into.
+		 */
+		private static function createBlocksFromString( s:String ):Array
+		{
+			var blocks:Array = new Array();
+			var len:int = s.length * 8;
+			var mask:int = 0xFF; // ignore hi byte of characters > 0xFF
+			for( var i:int = 0; i < len; i += 8 ) {
+				blocks[ i >> 5 ] |= ( s.charCodeAt( i / 8 ) & mask ) << ( 24 - i % 32 );
+			}
+			
+			// append padding and length
+			blocks[ len >> 5 ] |= 0x80 << ( 24 - len % 32 );
+			blocks[ ( ( ( len + 64 ) >> 9 ) << 4 ) + 15 ] = len;
+			return blocks;
+		}
+	}
+}

+/*
+  Copyright (c) 2008, Adobe Systems Incorporated
+  All rights reserved.
+
+  Redistribution and use in source and binary forms, with or without 
+  modification, are permitted provided that the following conditions are
+  met:
+
+  * Redistributions of source code must retain the above copyright notice, 
+    this list of conditions and the following disclaimer.
+  
+  * Redistributions in binary form must reproduce the above copyright
+    notice, this list of conditions and the following disclaimer in the 
+    documentation and/or other materials provided with the distribution.
+  
+  * Neither the name of Adobe Systems Incorporated nor the names of its 
+    contributors may be used to endorse or promote products derived from 
+    this software without specific prior written permission.
+
+  THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS
+  IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO,
+  THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR
+  PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT OWNER OR 
+  CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL,
+  EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO,
+  PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR
+  PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF
+  LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING
+  NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS
+  SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+*/
+
+package com.adobe.crypto
+{
+	import com.adobe.utils.IntUtil;
+	import flash.utils.ByteArray;
+	import mx.utils.Base64Encoder;
+	
+	/**
+	 * The SHA-256 algorithm
+	 * 
+	 * @see http://csrc.nist.gov/publications/fips/fips180-2/fips180-2withchangenotice.pdf
+	 */
+	public class SHA256
+	{
+		public static var digest:ByteArray;
+		/**
+		 *  Performs the SHA256 hash algorithm on a string.
+		 *
+		 *  @param s		The string to hash
+		 *  @return			A string containing the hash value of s
+		 *  @langversion	ActionScript 3.0
+		 *  @playerversion	9.0
+		 *  @tiptext
+		 */
+		public static function hash( s:String ):String {
+			var blocks:Array = createBlocksFromString( s );
+			var byteArray:ByteArray = hashBlocks( blocks );
+			
+			return IntUtil.toHex( byteArray.readInt(), true )
+					+ IntUtil.toHex( byteArray.readInt(), true )
+					+ IntUtil.toHex( byteArray.readInt(), true )
+					+ IntUtil.toHex( byteArray.readInt(), true )
+					+ IntUtil.toHex( byteArray.readInt(), true )
+					+ IntUtil.toHex( byteArray.readInt(), true )
+					+ IntUtil.toHex( byteArray.readInt(), true )
+					+ IntUtil.toHex( byteArray.readInt(), true );
+		}
+		
+		/**
+		 *  Performs the SHA256 hash algorithm on a ByteArray.
+		 *
+		 *  @param data		The ByteArray data to hash
+		 *  @return			A string containing the hash value of data
+		 *  @langversion	ActionScript 3.0
+		 *  @playerversion	9.0
+		 */
+		public static function hashBytes( data:ByteArray ):String
+		{
+			var blocks:Array = createBlocksFromByteArray( data );
+			var byteArray:ByteArray = hashBlocks(blocks);
+			
+			return IntUtil.toHex( byteArray.readInt(), true )
+					+ IntUtil.toHex( byteArray.readInt(), true )
+					+ IntUtil.toHex( byteArray.readInt(), true )
+					+ IntUtil.toHex( byteArray.readInt(), true )
+					+ IntUtil.toHex( byteArray.readInt(), true )
+					+ IntUtil.toHex( byteArray.readInt(), true )
+					+ IntUtil.toHex( byteArray.readInt(), true )
+					+ IntUtil.toHex( byteArray.readInt(), true );
+		}
+		
+		/**
+		 *  Performs the SHA256 hash algorithm on a string, then does
+		 *  Base64 encoding on the result.
+		 *
+		 *  @param s		The string to hash
+		 *  @return			The base64 encoded hash value of s
+		 *  @langversion	ActionScript 3.0
+		 *  @playerversion	9.0
+		 *  @tiptext
+		 */
+		public static function hashToBase64( s:String ):String
+		{
+			var blocks:Array = createBlocksFromString( s );
+			var byteArray:ByteArray = hashBlocks(blocks);
+
+			// ByteArray.toString() returns the contents as a UTF-8 string,
+			// which we can't use because certain byte sequences might trigger
+			// a UTF-8 conversion.  Instead, we convert the bytes to characters
+			// one by one.
+			var charsInByteArray:String = "";
+			byteArray.position = 0;
+			for (var j:int = 0; j < byteArray.length; j++)
+			{
+				var byte:uint = byteArray.readUnsignedByte();
+				charsInByteArray += String.fromCharCode(byte);
+			}
+
+			var encoder:Base64Encoder = new Base64Encoder();
+			encoder.encode(charsInByteArray);
+			return encoder.flush();
+		}
+		
+		private static function hashBlocks( blocks:Array ):ByteArray {
+			var h0:int = 0x6a09e667;
+			var h1:int = 0xbb67ae85;
+			var h2:int = 0x3c6ef372;
+			var h3:int = 0xa54ff53a;
+			var h4:int = 0x510e527f;
+			var h5:int = 0x9b05688c;
+			var h6:int = 0x1f83d9ab;
+			var h7:int = 0x5be0cd19;
+			
+			var k:Array = new Array(0x428a2f98, 0x71374491, 0xb5c0fbcf, 0xe9b5dba5, 0x3956c25b, 0x59f111f1, 0x923f82a4, 0xab1c5ed5, 0xd807aa98, 0x12835b01, 0x243185be, 0x550c7dc3, 0x72be5d74, 0x80deb1fe, 0x9bdc06a7, 0xc19bf174, 0xe49b69c1, 0xefbe4786, 0x0fc19dc6, 0x240ca1cc, 0x2de92c6f, 0x4a7484aa, 0x5cb0a9dc, 0x76f988da, 0x983e5152, 0xa831c66d, 0xb00327c8, 0xbf597fc7, 0xc6e00bf3, 0xd5a79147, 0x06ca6351, 0x14292967, 0x27b70a85, 0x2e1b2138, 0x4d2c6dfc, 0x53380d13, 0x650a7354, 0x766a0abb, 0x81c2c92e, 0x92722c85, 0xa2bfe8a1, 0xa81a664b, 0xc24b8b70, 0xc76c51a3, 0xd192e819, 0xd6990624, 0xf40e3585, 0x106aa070, 0x19a4c116, 0x1e376c08, 0x2748774c, 0x34b0bcb5, 0x391c0cb3, 0x4ed8aa4a, 0x5b9cca4f, 0x682e6ff3, 0x748f82ee, 0x78a5636f, 0x84c87814, 0x8cc70208, 0x90befffa, 0xa4506ceb, 0xbef9a3f7, 0xc67178f2);
+			
+			var len:int = blocks.length;
+			var w:Array = new Array( 64 );
+			
+			// loop over all of the blocks
+			for ( var i:int = 0; i < len; i += 16 ) {
+				
+				var a:int = h0;
+				var b:int = h1;
+				var c:int = h2;
+				var d:int = h3;
+				var e:int = h4;
+				var f:int = h5;
+				var g:int = h6;
+				var h:int = h7;
+				
+				for(var t:int = 0; t < 64; t++) {
+					
+					if ( t < 16 ) {
+						w[t] = blocks[ i + t ];
+						if(isNaN(w[t])) { w[t] = 0; }
+					} else {
+						var ws0:int = IntUtil.ror(w[t-15], 7) ^ IntUtil.ror(w[t-15], 18) ^ (w[t-15] >>> 3);
+						var ws1:int = IntUtil.ror(w[t-2], 17) ^ IntUtil.ror(w[t-2], 19) ^ (w[t-2] >>> 10);
+						w[t] = w[t-16] + ws0 + w[t-7] + ws1;
+					}
+					
+					var s0:int = IntUtil.ror(a, 2) ^ IntUtil.ror(a, 13) ^ IntUtil.ror(a, 22);
+					var maj:int = (a & b) ^ (a & c) ^ (b & c);
+					var t2:int = s0 + maj;
+					var s1:int = IntUtil.ror(e, 6) ^ IntUtil.ror(e, 11) ^ IntUtil.ror(e, 25);
+					var ch:int = (e & f) ^ ((~e) & g);
+					var t1:int = h + s1 + ch + k[t] + w[t];
+					
+					h = g;
+					g = f;
+					f = e;
+					e = d + t1;
+					d = c;
+					c = b;
+					b = a;
+					a = t1 + t2;
+				}
+					
+				//Add this chunk's hash to result so far:
+				h0 += a;
+				h1 += b;
+				h2 += c;
+				h3 += d;
+				h4 += e;
+				h5 += f;
+				h6 += g;
+				h7 += h;
+			}
+			
+			var byteArray:ByteArray = new ByteArray();
+			byteArray.writeInt(h0);
+			byteArray.writeInt(h1);
+			byteArray.writeInt(h2);
+			byteArray.writeInt(h3);
+			byteArray.writeInt(h4);
+			byteArray.writeInt(h5);
+			byteArray.writeInt(h6);
+			byteArray.writeInt(h7);
+			byteArray.position = 0;
+			
+			digest = new ByteArray();
+			digest.writeBytes(byteArray);
+			digest.position = 0;
+			return byteArray;
+		}
+		
+		/**
+		 *  Converts a ByteArray to a sequence of 16-word blocks
+		 *  that we'll do the processing on.  Appends padding
+		 *  and length in the process.
+		 *
+		 *  @param data		The data to split into blocks
+		 *  @return			An array containing the blocks into which data was split
+		 */
+		private static function createBlocksFromByteArray( data:ByteArray ):Array
+		{
+			var oldPosition:int = data.position;
+			data.position = 0;
+			
+			var blocks:Array = new Array();
+			var len:int = data.length * 8;
+			var mask:int = 0xFF; // ignore hi byte of characters > 0xFF
+			for( var i:int = 0; i < len; i += 8 )
+			{
+				blocks[ i >> 5 ] |= ( data.readByte() & mask ) << ( 24 - i % 32 );
+			}
+			
+			// append padding and length
+			blocks[ len >> 5 ] |= 0x80 << ( 24 - len % 32 );
+			blocks[ ( ( ( len + 64 ) >> 9 ) << 4 ) + 15 ] = len;
+			
+			data.position = oldPosition;
+			
+			return blocks;
+		}
+					
+		/**
+		 *  Converts a string to a sequence of 16-word blocks
+		 *  that we'll do the processing on.  Appends padding
+		 *  and length in the process.
+		 *
+		 *  @param s	The string to split into blocks
+		 *  @return		An array containing the blocks that s was split into.
+		 */
+		private static function createBlocksFromString( s:String ):Array
+		{
+			var blocks:Array = new Array();
+			var len:int = s.length * 8;
+			var mask:int = 0xFF; // ignore hi byte of characters > 0xFF
+			for( var i:int = 0; i < len; i += 8 ) {
+				blocks[ i >> 5 ] |= ( s.charCodeAt( i / 8 ) & mask ) << ( 24 - i % 32 );
+			}
+			
+			// append padding and length
+			blocks[ len >> 5 ] |= 0x80 << ( 24 - len % 32 );
+			blocks[ ( ( ( len + 64 ) >> 9 ) << 4 ) + 15 ] = len;
+			return blocks;
+		}
+	}
+}

+/*
+  Copyright (c) 2008, Adobe Systems Incorporated
+  All rights reserved.
+
+  Redistribution and use in source and binary forms, with or without 
+  modification, are permitted provided that the following conditions are
+  met:
+
+  * Redistributions of source code must retain the above copyright notice, 
+    this list of conditions and the following disclaimer.
+  
+  * Redistributions in binary form must reproduce the above copyright
+    notice, this list of conditions and the following disclaimer in the 
+    documentation and/or other materials provided with the distribution.
+  
+  * Neither the name of Adobe Systems Incorporated nor the names of its 
+    contributors may be used to endorse or promote products derived from 
+    this software without specific prior written permission.
+
+  THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS
+  IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO,
+  THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR
+  PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT OWNER OR 
+  CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL,
+  EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO,
+  PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR
+  PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF
+  LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING
+  NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS
+  SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+*/
+
+package com.adobe.crypto
+{
+	import mx.formatters.DateFormatter;
+	import mx.utils.Base64Encoder;
+	
+	/**
+	 * Web Services Security Username Token
+	 *
+	 * Implementation based on algorithm description at 
+	 * http://www.oasis-open.org/committees/wss/documents/WSS-Username-02-0223-merged.pdf
+	 */
+	public class WSSEUsernameToken
+	{
+		/**
+		 * Generates a WSSE Username Token.
+		 *
+		 * @param username The username
+		 * @param password The password
+		 * @param nonce A cryptographically random nonce (if null, the nonce
+		 * will be generated)
+		 * @param timestamp The time at which the token is generated (if null,
+		 * the time will be set to the moment of execution)
+		 * @return The generated token
+		 * @langversion ActionScript 3.0
+		 * @playerversion Flash 9.0
+		 * @tiptext
+		 */
+		public static function getUsernameToken(username:String, password:String, nonce:String=null, timestamp:Date=null):String
+		{
+			if (nonce == null)
+			{
+				nonce = generateNonce();
+			}
+			nonce = base64Encode(nonce);
+		
+			var created:String = generateTimestamp(timestamp);
+		
+			var password64:String = getBase64Digest(nonce,
+				created,
+				password);
+		
+			var token:String = new String("UsernameToken Username=\"");
+			token += username + "\", " +
+					 "PasswordDigest=\"" + password64 + "\", " +
+					 "Nonce=\"" + nonce + "\", " +
+					 "Created=\"" + created + "\"";
+			return token;
+		}
+		
+		private static function generateNonce():String
+		{
+			// Math.random returns a Number between 0 and 1.  We don't want our
+			// nonce to contain invalid characters (e.g. the period) so we
+			// strip them out before returning the result.
+			var s:String =  Math.random().toString();
+			return s.replace(".", "");
+		}
+		
+		internal static function base64Encode(s:String):String
+		{
+			var encoder:Base64Encoder = new Base64Encoder();
+			encoder.encode(s);
+			return encoder.flush();
+		}
+		
+		internal static function generateTimestamp(timestamp:Date):String
+		{
+			if (timestamp == null)
+			{
+				timestamp = new Date();
+			}
+			var dateFormatter:DateFormatter = new DateFormatter();
+			dateFormatter.formatString = "YYYY-MM-DDTJJ:NN:SS"
+			return dateFormatter.format(timestamp) + "Z";
+		}
+		
+		internal static function getBase64Digest(nonce:String, created:String, password:String):String
+		{
+			return SHA1.hashToBase64(nonce + created + password);
+		}
+	}
+}
\ No newline at end of file

+/*
+  Copyright (c) 2008, Adobe Systems Incorporated
+  All rights reserved.
+
+  Redistribution and use in source and binary forms, with or without 
+  modification, are permitted provided that the following conditions are
+  met:
+
+  * Redistributions of source code must retain the above copyright notice, 
+    this list of conditions and the following disclaimer.
+  
+  * Redistributions in binary form must reproduce the above copyright
+    notice, this list of conditions and the following disclaimer in the 
+    documentation and/or other materials provided with the distribution.
+  
+  * Neither the name of Adobe Systems Incorporated nor the names of its 
+    contributors may be used to endorse or promote products derived from 
+    this software without specific prior written permission.
+
+  THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS
+  IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO,
+  THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR
+  PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT OWNER OR 
+  CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL,
+  EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO,
+  PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR
+  PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF
+  LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING
+  NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS
+  SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+*/
+
+package com.adobe.errors
+{
+	/**
+	* This class represents an Error that is thrown when a method is called when
+	* the receiving instance is in an invalid state.
+	*
+	* For example, this may occur if a method has been called, and other properties
+	* in the instance have not been initialized properly.
+	*
+	* @langversion ActionScript 3.0
+	* @playerversion Flash 9.0
+	* @tiptext
+	*
+	*/
+	public class IllegalStateError extends Error
+	{
+		/**
+		*	Constructor
+		*
+		*	@param message A message describing the error in detail.
+		*
+		* 	@langversion ActionScript 3.0
+		*	@playerversion Flash 9.0
+		*	@tiptext
+		*/
+		public function IllegalStateError(message:String)
+		{
+			super(message);
+		}
+	}
+}
\ No newline at end of file

+/*
+  Copyright (c) 2008, Adobe Systems Incorporated
+  All rights reserved.
+
+  Redistribution and use in source and binary forms, with or without 
+  modification, are permitted provided that the following conditions are
+  met:
+
+  * Redistributions of source code must retain the above copyright notice, 
+    this list of conditions and the following disclaimer.
+  
+  * Redistributions in binary form must reproduce the above copyright
+    notice, this list of conditions and the following disclaimer in the 
+    documentation and/or other materials provided with the distribution.
+  
+  * Neither the name of Adobe Systems Incorporated nor the names of its 
+    contributors may be used to endorse or promote products derived from 
+    this software without specific prior written permission.
+
+  THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS
+  IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO,
+  THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR
+  PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT OWNER OR 
+  CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL,
+  EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO,
+  PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR
+  PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF
+  LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING
+  NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS
+  SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+*/
+package com.adobe.fileformats.vcard
+{
+	public class Address
+	{
+		public var type:String;
+		public var street:String;
+		public var city:String;
+		public var state:String;
+		public var postalCode:String;
+		
+		public function toString():String
+		{
+			return (street + " " + city + ", " + state + " " + postalCode);
+		}
+	}
+}
\ No newline at end of file

+/*
+  Copyright (c) 2008, Adobe Systems Incorporated
+  All rights reserved.
+
+  Redistribution and use in source and binary forms, with or without 
+  modification, are permitted provided that the following conditions are
+  met:
+
+  * Redistributions of source code must retain the above copyright notice, 
+    this list of conditions and the following disclaimer.
+  
+  * Redistributions in binary form must reproduce the above copyright
+    notice, this list of conditions and the following disclaimer in the 
+    documentation and/or other materials provided with the distribution.
+  
+  * Neither the name of Adobe Systems Incorporated nor the names of its 
+    contributors may be used to endorse or promote products derived from 
+    this software without specific prior written permission.
+
+  THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS
+  IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO,
+  THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR
+  PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT OWNER OR 
+  CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL,
+  EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO,
+  PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR
+  PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF
+  LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING
+  NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS
+  SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+*/
+package com.adobe.fileformats.vcard
+{
+	public class Email
+	{
+		public var type:String;
+		public var address:String;
+	}
+}
\ No newline at end of file

+/*
+  Copyright (c) 2008, Adobe Systems Incorporated
+  All rights reserved.
+
+  Redistribution and use in source and binary forms, with or without 
+  modification, are permitted provided that the following conditions are
+  met:
+
+  * Redistributions of source code must retain the above copyright notice, 
+    this list of conditions and the following disclaimer.
+  
+  * Redistributions in binary form must reproduce the above copyright
+    notice, this list of conditions and the following disclaimer in the 
+    documentation and/or other materials provided with the distribution.
+  
+  * Neither the name of Adobe Systems Incorporated nor the names of its 
+    contributors may be used to endorse or promote products derived from 
+    this software without specific prior written permission.
+
+  THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS
+  IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO,
+  THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR
+  PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT OWNER OR 
+  CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL,
+  EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO,
+  PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR
+  PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF
+  LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING
+  NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS
+  SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+*/
+package com.adobe.fileformats.vcard
+{
+	public class Phone
+	{
+		public var type:String;
+		public var number:String;
+	}
+}
\ No newline at end of file

+/*
+  Copyright (c) 2008, Adobe Systems Incorporated
+  All rights reserved.
+
+  Redistribution and use in source and binary forms, with or without 
+  modification, are permitted provided that the following conditions are
+  met:
+
+  * Redistributions of source code must retain the above copyright notice, 
+    this list of conditions and the following disclaimer.
+  
+  * Redistributions in binary form must reproduce the above copyright
+    notice, this list of conditions and the following disclaimer in the 
+    documentation and/or other materials provided with the distribution.
+  
+  * Neither the name of Adobe Systems Incorporated nor the names of its 
+    contributors may be used to endorse or promote products derived from 
+    this software without specific prior written permission.
+
+  THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS
+  IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO,
+  THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR
+  PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT OWNER OR 
+  CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL,
+  EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO,
+  PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR
+  PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF
+  LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING
+  NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS
+  SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+*/
+package com.adobe.fileformats.vcard
+{
+	import flash.utils.ByteArray;
+
+	public class VCard
+	{
+		public var fullName:String;
+		public var orgs:Array;
+		public var title:String;
+		public var image:ByteArray;
+		public var phones:Array;
+		public var emails:Array;
+		public var addresses:Array;
+		
+		public function VCard()
+		{
+			orgs = new Array();
+			phones = new Array();
+			emails = new Array();
+			addresses = new Array();
+		}
+	}
+}
\ No newline at end of file

+/*
+  Copyright (c) 2008, Adobe Systems Incorporated
+  All rights reserved.
+
+  Redistribution and use in source and binary forms, with or without 
+  modification, are permitted provided that the following conditions are
+  met:
+
+  * Redistributions of source code must retain the above copyright notice, 
+    this list of conditions and the following disclaimer.
+  
+  * Redistributions in binary form must reproduce the above copyright
+    notice, this list of conditions and the following disclaimer in the 
+    documentation and/or other materials provided with the distribution.
+  
+  * Neither the name of Adobe Systems Incorporated nor the names of its 
+    contributors may be used to endorse or promote products derived from 
+    this software without specific prior written permission.
+
+  THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS
+  IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO,
+  THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR
+  PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT OWNER OR 
+  CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL,
+  EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO,
+  PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR
+  PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF
+  LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING
+  NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS
+  SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+*/
+package com.adobe.fileformats.vcard
+{
+	import mx.utils.Base64Decoder;
+	import mx.utils.StringUtil;
+	
+	public class VCardParser
+	{
+		public static function parse(vcardStr:String):Array
+		{
+			var vcards:Array = new Array();
+			var lines:Array = vcardStr.split(/\r\n/);
+			var vcard:VCard;
+			var type:String;
+			var typeTmp:String;
+			var line:String;
+
+			for (var i:uint = 0; i < lines.length; ++i)
+			{
+				line = lines[i];
+				if (line == "BEGIN:VCARD")
+				{
+					vcard = new VCard();
+				}
+				else if (line == "END:VCARD")
+				{
+					if (vcard != null)
+					{
+						vcards.push(vcard);
+					}
+				}
+				else if(line.search(/^ORG/i) != -1)
+				{
+					var org:String = line.substring(4, line.length);
+					var orgArray:Array = org.split(";");
+					for each (var orgToken:String in orgArray)
+					{
+						if (StringUtil.trim(orgToken).length > 0)
+						{
+							vcard.orgs.push(orgToken);
+						}
+					}
+				}
+				else if(line.search(/^TITLE/i) != -1)
+				{
+					var title:String = line.substring(6, line.length);
+					vcard.title = title;
+				}
+				else if (line.search(/^FN:/i) != -1)
+				{
+					var fullName:String = line.substring(3, line.length);
+					vcard.fullName = fullName;
+				}
+				else if (line.search(/^TEL/i) != -1)
+				{
+					type = new String();
+					typeTmp = new String();
+					var phone:Phone = new Phone();
+					var number:String;
+					var phoneTokens:Array = line.split(";");
+					for each (var phoneToken:String in phoneTokens)
+					{
+						if (phoneToken.search(/^TYPE=/i) != -1)
+						{
+							if (phoneToken.indexOf(":") != -1)
+							{
+								typeTmp = phoneToken.substring(5, phoneToken.indexOf(":"));
+								number = phoneToken.substring(phoneToken.indexOf(":")+1, phoneToken.length);
+							}
+							else
+							{									
+								typeTmp = phoneToken.substring(5, phoneToken.length);
+							}
+
+							typeTmp = typeTmp.toLocaleLowerCase();
+
+							if (typeTmp == "pref")
+							{
+								continue;
+							}
+							if (type.length != 0)
+							{
+								type += (" ");
+							}
+							type += typeTmp;
+						}
+					}
+					if (type.length > 0 && number != null)
+					{
+						phone.type = type;
+						phone.number = number;
+					}
+					vcard.phones.push(phone);
+				}
+				else if (line.search(/^EMAIL/i) != -1)
+				{
+					type = new String();
+					typeTmp = new String();
+					var email:Email = new Email();
+					var emailAddress:String;
+					var emailTokens:Array = line.split(";");
+					for each (var emailToken:String in emailTokens)
+					{
+						if (emailToken.search(/^TYPE=/i) != -1)
+						{
+							if (emailToken.indexOf(":") != -1)
+							{
+								typeTmp = emailToken.substring(5, emailToken.indexOf(":"));
+								emailAddress = emailToken.substring(emailToken.indexOf(":")+1, emailToken.length);
+							}
+							else
+							{									
+								typeTmp = emailToken.substring(5, emailToken.length);
+							}
+
+							typeTmp = typeTmp.toLocaleLowerCase();
+
+							if (typeTmp == "pref" || typeTmp == "internet")
+							{
+								continue;
+							}
+							if (type.length != 0)
+							{
+								type += (" ");
+							}
+							type += typeTmp;
+						}
+					}
+					if (type.length > 0 && emailAddress != null)
+					{
+						email.type = type;
+						email.address = emailAddress;
+					}
+					vcard.emails.push(email);
+				}
+				else if (line.indexOf("ADR;") != -1)
+				{
+					var addressTokens:Array = line.split(";");
+					var address:Address = new Address();
+					for (var j:uint = 0; j < addressTokens.length; ++j)
+					{
+						var addressToken:String = addressTokens[j];
+						if (addressToken.search(/^home:+$/i) != -1) // For Outlook, which uses non-standard vCards.
+						{
+							address.type = "home";
+						}
+						else if (addressToken.search(/^work:+$/i) != -1) // For Outlook, which uses non-standard vCards.
+						{
+							address.type = "work";
+						}
+						if (addressToken.search(/^type=/i) != -1)  // The "type" parameter is the standard way (which Address Book uses)
+						{
+							// First, remove the optional ":" character.
+							addressToken = addressToken.replace(/:/,"");
+							var addressType:String = addressToken.substring(5, addressToken.length).toLowerCase();
+							if (addressType == "pref") // Not interested in which one is preferred.
+							{
+								continue;
+							}
+							else if (addressType.indexOf("home") != -1) // home
+							{
+								addressType = "home";
+							}
+							else if (addressType.indexOf("work") != -1) // work
+							{
+								addressType = "work";
+							}
+							else if (addressType.indexOf(",") != -1) // if the comma technique is used, just use the first one
+							{
+								var typeTokens:Array = addressType.split(",");
+								for each (var typeToken:String in typeTokens)
+								{
+									if (typeToken != "pref")
+									{
+										addressType = typeToken;
+										break;
+									}
+								}
+							}
+							address.type = addressType;
+						}
+						else if (addressToken.search(/^\d/) != -1 && address.street == null)
+						{
+							address.street = addressToken.replace(/\\n/, "");
+							address.city = addressTokens[j+1];
+							address.state = addressTokens[j+2];
+							address.postalCode = addressTokens[j+3];
+						}
+					}
+					if (address.type != null && address.street != null)
+					{
+						vcard.addresses.push(address);
+					}
+
+				}
+				else if (line.search(/^PHOTO;BASE64/i) != -1)
+				{
+					var imageStr:String = new String();
+					for (var k:uint = i+1; k < lines.length; ++k)
+					{
+						imageStr += lines[k];
+						//if (lines[k].search(/.+\=$/) != -1) // Very slow in Mac due to RegEx bug
+						if (lines[k].indexOf('=') != -1)
+						{
+							var decoder:Base64Decoder = new Base64Decoder();
+							decoder.decode(imageStr);
+							vcard.image = decoder.flush();
+							break;
+						}
+					}
+				}
+			}
+			return vcards;
+		}
+	}
+}
\ No newline at end of file

+/*
+  Copyright (c) 2008, Adobe Systems Incorporated
+  All rights reserved.
+
+  Redistribution and use in source and binary forms, with or without 
+  modification, are permitted provided that the following conditions are
+  met:
+
+  * Redistributions of source code must retain the above copyright notice, 
+    this list of conditions and the following disclaimer.
+  
+  * Redistributions in binary form must reproduce the above copyright
+    notice, this list of conditions and the following disclaimer in the 
+    documentation and/or other materials provided with the distribution.
+  
+  * Neither the name of Adobe Systems Incorporated nor the names of its 
+    contributors may be used to endorse or promote products derived from 
+    this software without specific prior written permission.
+
+  THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS
+  IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO,
+  THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR
+  PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT OWNER OR 
+  CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL,
+  EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO,
+  PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR
+  PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF
+  LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING
+  NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS
+  SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+*/
+package com.adobe.images
+{
+	public class BitString
+	{
+		public var len:int = 0;
+		public var val:int = 0;
+	}
+}
\ No newline at end of file

+/*
+  Copyright (c) 2008, Adobe Systems Incorporated
+  All rights reserved.
+
+  Redistribution and use in source and binary forms, with or without 
+  modification, are permitted provided that the following conditions are
+  met:
+
+  * Redistributions of source code must retain the above copyright notice, 
+    this list of conditions and the following disclaimer.
+  
+  * Redistributions in binary form must reproduce the above copyright
+    notice, this list of conditions and the following disclaimer in the 
+    documentation and/or other materials provided with the distribution.
+  
+  * Neither the name of Adobe Systems Incorporated nor the names of its 
+    contributors may be used to endorse or promote products derived from 
+    this software without specific prior written permission.
+
+  THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS
+  IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO,
+  THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR
+  PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT OWNER OR 
+  CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL,
+  EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO,
+  PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR
+  PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF
+  LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING
+  NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS
+  SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+*/
+package com.adobe.images
+{
+	import flash.geom.*;
+	import flash.display.Bitmap;
+	import flash.display.BitmapData;
+	import flash.utils.ByteArray;
+
+	/**
+	 * Class that converts BitmapData into a valid PNG
+	 */	
+	public class PNGEncoder
+	{
+		/**
+		 * Created a PNG image from the specified BitmapData
+		 *
+		 * @param image The BitmapData that will be converted into the PNG format.
+		 * @return a ByteArray representing the PNG encoded image data.
+		 * @langversion ActionScript 3.0
+		 * @playerversion Flash 9.0
+		 * @tiptext
+		 */			
+	    public static function encode(img:BitmapData):ByteArray {
+	        // Create output byte array
+	        var png:ByteArray = new ByteArray();
+	        // Write PNG signature
+	        png.writeUnsignedInt(0x89504e47);
+	        png.writeUnsignedInt(0x0D0A1A0A);
+	        // Build IHDR chunk
+	        var IHDR:ByteArray = new ByteArray();
+	        IHDR.writeInt(img.width);
+	        IHDR.writeInt(img.height);
+	        IHDR.writeUnsignedInt(0x08060000); // 32bit RGBA
+	        IHDR.writeByte(0);
+	        writeChunk(png,0x49484452,IHDR);
+	        // Build IDAT chunk
+	        var IDAT:ByteArray= new ByteArray();
+	        for(var i:int=0;i < img.height;i++) {
+	            // no filter
+	            IDAT.writeByte(0);
+	            var p:uint;
+	            var j:int;
+	            if ( !img.transparent ) {
+	                for(j=0;j < img.width;j++) {
+	                    p = img.getPixel(j,i);
+	                    IDAT.writeUnsignedInt(
+	                        uint(((p&0xFFFFFF) << 8)|0xFF));
+	                }
+	            } else {
+	                for(j=0;j < img.width;j++) {
+	                    p = img.getPixel32(j,i);
+	                    IDAT.writeUnsignedInt(
+	                        uint(((p&0xFFFFFF) << 8)|
+	                        (p>>>24)));
+	                }
+	            }
+	        }
+	        IDAT.compress();
+	        writeChunk(png,0x49444154,IDAT);
+	        // Build IEND chunk
+	        writeChunk(png,0x49454E44,null);
+	        // return PNG
+	        return png;
+	    }
+	
+	    private static var crcTable:Array;
+	    private static var crcTableComputed:Boolean = false;
+	
+	    private static function writeChunk(png:ByteArray, 
+	            type:uint, data:ByteArray):void {
+	        if (!crcTableComputed) {
+	            crcTableComputed = true;
+	            crcTable = [];
+	            var c:uint;
+	            for (var n:uint = 0; n < 256; n++) {
+	                c = n;
+	                for (var k:uint = 0; k < 8; k++) {
+	                    if (c & 1) {
+	                        c = uint(uint(0xedb88320) ^ 
+	                            uint(c >>> 1));
+	                    } else {
+	                        c = uint(c >>> 1);
+	                    }
+	                }
+	                crcTable[n] = c;
+	            }
+	        }
+	        var len:uint = 0;
+	        if (data != null) {
+	            len = data.length;
+	        }
+	        png.writeUnsignedInt(len);
+	        var p:uint = png.position;
+	        png.writeUnsignedInt(type);
+	        if ( data != null ) {
+	            png.writeBytes(data);
+	        }
+	        var e:uint = png.position;
+	        png.position = p;
+	        c = 0xffffffff;
+	        for (var i:int = 0; i < (e-p); i++) {
+	            c = uint(crcTable[
+	                (c ^ png.readUnsignedByte()) & 
+	                uint(0xff)] ^ uint(c >>> 8));
+	        }
+	        c = uint(c^uint(0xffffffff));
+	        png.position = e;
+	        png.writeUnsignedInt(c);
+	    }
+	}
+}
\ No newline at end of file

+/*
+  Copyright (c) 2008, Adobe Systems Incorporated
+  All rights reserved.
+
+  Redistribution and use in source and binary forms, with or without 
+  modification, are permitted provided that the following conditions are
+  met:
+
+  * Redistributions of source code must retain the above copyright notice, 
+    this list of conditions and the following disclaimer.
+  
+  * Redistributions in binary form must reproduce the above copyright
+    notice, this list of conditions and the following disclaimer in the 
+    documentation and/or other materials provided with the distribution.
+  
+  * Neither the name of Adobe Systems Incorporated nor the names of its 
+    contributors may be used to endorse or promote products derived from 
+    this software without specific prior written permission.
+
+  THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS
+  IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO,
+  THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR
+  PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT OWNER OR 
+  CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL,
+  EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO,
+  PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR
+  PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF
+  LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING
+  NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS
+  SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+*/
+
+package com.adobe.net
+{
+	import flash.net.URLLoader;
+
+	/**
+	* 	Class that provides a dynamic implimentation of the URLLoader class.
+	* 
+	* 	This class provides no API implimentations. However, since the class is
+	* 	declared as dynamic, it can be used in place of URLLoader, and allow
+	* 	you to dynamically attach properties to it (which URLLoader does not allow).
+	* 
+	* 	@langversion ActionScript 3.0
+	*	@playerversion Flash 9.0
+	*	@tiptext
+	*/	
+	public dynamic class DynamicURLLoader extends URLLoader 
+	{
+		public function DynamicURLLoader()
+		{
+			super();
+		}
+	}
+}
\ No newline at end of file

+/*
+  Copyright (c) 2008, Adobe Systems Incorporated
+  All rights reserved.
+
+  Redistribution and use in source and binary forms, with or without 
+  modification, are permitted provided that the following conditions are
+  met:
+
+  * Redistributions of source code must retain the above copyright notice, 
+    this list of conditions and the following disclaimer.
+  
+  * Redistributions in binary form must reproduce the above copyright
+    notice, this list of conditions and the following disclaimer in the 
+    documentation and/or other materials provided with the distribution.
+  
+  * Neither the name of Adobe Systems Incorporated nor the names of its 
+    contributors may be used to endorse or promote products derived from 
+    this software without specific prior written permission.
+
+  THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS
+  IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO,
+  THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR
+  PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT OWNER OR 
+  CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL,
+  EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO,
+  PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR
+  PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF
+  LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING
+  NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS
+  SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+*/
+
+package com.adobe.net
+{
+	/**
+	 * The URI class cannot know about DNS aliases, virtual hosts, or
+	 * symbolic links that may be involved.  The application can provide
+	 * an implementation of this interface to resolve the URI before the
+	 * URI class makes any comparisons.  For example, a web host has
+	 * two aliases:
+	 * 
+	 * <p><code>
+	 *    http://www.site.com/
+	 *    http://www.site.net/
+	 * </code></p>
+	 * 
+	 * <p>The application can provide an implementation that automatically
+	 * resolves site.net to site.com before URI compares two URI objects.
+	 * Only the application can know and understand the context in which
+	 * the URI's are being used.</p>
+	 * 
+	 * <p>Use the URI.resolver accessor to assign a custom resolver to
+	 * the URI class.  Any resolver specified is global to all instances
+	 * of URI.</p>
+	 * 
+	 * <p>URI will call this before performing URI comparisons in the
+	 * URI.getRelation() and URI.getCommonParent() functions.
+	 * 
+	 * @see URI.getRelation
+	 * @see URI.getCommonParent
+	 * 
+	 * @langversion ActionScript 3.0
+	 * @playerversion Flash 9.0
+	 */
+	public interface IURIResolver
+	{
+		/**
+		 * Implement this method to provide custom URI resolution for
+		 * your application.
+		 * 
+		 * @langversion ActionScript 3.0
+		 * @playerversion Flash 9.0
+		 */
+		function resolve(uri:URI) : URI;
+	}
+}
\ No newline at end of file

+/*
+  Copyright (c) 2008, Adobe Systems Incorporated
+  All rights reserved.
+
+  Redistribution and use in source and binary forms, with or without 
+  modification, are permitted provided that the following conditions are
+  met:
+
+  * Redistributions of source code must retain the above copyright notice, 
+    this list of conditions and the following disclaimer.
+  
+  * Redistributions in binary form must reproduce the above copyright
+    notice, this list of conditions and the following disclaimer in the 
+    documentation and/or other materials provided with the distribution.
+  
+  * Neither the name of Adobe Systems Incorporated nor the names of its 
+    contributors may be used to endorse or promote products derived from 
+    this software without specific prior written permission.
+
+  THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS
+  IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO,
+  THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR
+  PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT OWNER OR 
+  CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL,
+  EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO,
+  PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR
+  PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF
+  LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING
+  NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS
+  SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+*/
+package com.adobe.net
+{
+	public class MimeTypeMap
+	{
+		private var types:Array = 
+			[["application/andrew-inset","ez"],
+			["application/atom+xml","atom"],
+			["application/mac-binhex40","hqx"],
+			["application/mac-compactpro","cpt"],
+			["application/mathml+xml","mathml"],
+			["application/msword","doc"],
+			["application/octet-stream","bin","dms","lha","lzh","exe","class","so","dll","dmg"],
+			["application/oda","oda"],
+			["application/ogg","ogg"],
+			["application/pdf","pdf"],
+			["application/postscript","ai","eps","ps"],
+			["application/rdf+xml","rdf"],
+			["application/smil","smi","smil"],
+			["application/srgs","gram"],
+			["application/srgs+xml","grxml"],
+			["application/vnd.adobe.apollo-application-installer-package+zip","air"],
+			["application/vnd.mif","mif"],
+			["application/vnd.mozilla.xul+xml","xul"],
+			["application/vnd.ms-excel","xls"],
+			["application/vnd.ms-powerpoint","ppt"],
+			["application/vnd.rn-realmedia","rm"],
+			["application/vnd.wap.wbxml","wbxml"],
+			["application/vnd.wap.wmlc","wmlc"],
+			["application/vnd.wap.wmlscriptc","wmlsc"],
+			["application/voicexml+xml","vxml"],
+			["application/x-bcpio","bcpio"],
+			["application/x-cdlink","vcd"],
+			["application/x-chess-pgn","pgn"],
+			["application/x-cpio","cpio"],
+			["application/x-csh","csh"],
+			["application/x-director","dcr","dir","dxr"],
+			["application/x-dvi","dvi"],
+			["application/x-futuresplash","spl"],
+			["application/x-gtar","gtar"],
+			["application/x-hdf","hdf"],
+			["application/x-javascript","js"],
+			["application/x-koan","skp","skd","skt","skm"],
+			["application/x-latex","latex"],
+			["application/x-netcdf","nc","cdf"],
+			["application/x-sh","sh"],
+			["application/x-shar","shar"],
+			["application/x-shockwave-flash","swf"],
+			["application/x-stuffit","sit"],
+			["application/x-sv4cpio","sv4cpio"],
+			["application/x-sv4crc","sv4crc"],
+			["application/x-tar","tar"],
+			["application/x-tcl","tcl"],
+			["application/x-tex","tex"],
+			["application/x-texinfo","texinfo","texi"],
+			["application/x-troff","t","tr","roff"],
+			["application/x-troff-man","man"],
+			["application/x-troff-me","me"],
+			["application/x-troff-ms","ms"],
+			["application/x-ustar","ustar"],
+			["application/x-wais-source","src"],
+			["application/xhtml+xml","xhtml","xht"],
+			["application/xml","xml","xsl"],
+			["application/xml-dtd","dtd"],
+			["application/xslt+xml","xslt"],
+			["application/zip","zip"],
+			["audio/basic","au","snd"],
+			["audio/midi","mid","midi","kar"],
+			["audio/mpeg","mp3","mpga","mp2"],
+			["audio/x-aiff","aif","aiff","aifc"],
+			["audio/x-mpegurl","m3u"],
+			["audio/x-pn-realaudio","ram","ra"],
+			["audio/x-wav","wav"],
+			["chemical/x-pdb","pdb"],
+			["chemical/x-xyz","xyz"],
+			["image/bmp","bmp"],
+			["image/cgm","cgm"],
+			["image/gif","gif"],
+			["image/ief","ief"],
+			["image/jpeg","jpg","jpeg","jpe"],
+			["image/png","png"],
+			["image/svg+xml","svg"],
+			["image/tiff","tiff","tif"],
+			["image/vnd.djvu","djvu","djv"],
+			["image/vnd.wap.wbmp","wbmp"],
+			["image/x-cmu-raster","ras"],
+			["image/x-icon","ico"],
+			["image/x-portable-anymap","pnm"],
+			["image/x-portable-bitmap","pbm"],
+			["image/x-portable-graymap","pgm"],
+			["image/x-portable-pixmap","ppm"],
+			["image/x-rgb","rgb"],
+			["image/x-xbitmap","xbm"],
+			["image/x-xpixmap","xpm"],
+			["image/x-xwindowdump","xwd"],
+			["model/iges","igs","iges"],
+			["model/mesh","msh","mesh","silo"],
+			["model/vrml","wrl","vrml"],
+			["text/calendar","ics","ifb"],
+			["text/css","css"],
+			["text/html","html","htm"],
+			["text/plain","txt","asc"],
+			["text/richtext","rtx"],
+			["text/rtf","rtf"],
+			["text/sgml","sgml","sgm"],
+			["text/tab-separated-values","tsv"],
+			["text/vnd.wap.wml","wml"],
+			["text/vnd.wap.wmlscript","wmls"],
+			["text/x-setext","etx"],
+			["video/mpeg","mpg","mpeg","mpe"],
+			["video/quicktime","mov","qt"],
+			["video/vnd.mpegurl","m4u","mxu"],
+			["video/x-flv","flv"],
+			["video/x-msvideo","avi"],
+			["video/x-sgi-movie","movie"],
+			["x-conference/x-cooltalk","ice"]];
+		
+		/**
+		 * Returns the mimetype for the given extension.
+		 */
+		public function getMimeType(extension:String):String
+		{
+			extension = extension.toLocaleLowerCase();
+			for each (var a:Array in types)
+			{
+				for each (var b:String in a)
+				{
+					if (b == extension)
+					{
+						return a[0];
+					}
+				}
+			}
+			return null;
+		}
+
+		/**
+		 * Returns the prefered extension for the given mimetype.
+		 */
+		public function getExtension(mimetype:String):String
+		{
+			mimetype = mimetype.toLocaleLowerCase();
+			for each (var a:Array in types)
+			{
+				if (a[0] == mimetype)
+				{
+					return a[1];
+				}
+			}
+			return null;
+		}
+
+		/**
+		 * Adds a mimetype to the map. The order of the extensions matters. The most preferred should come first.
+		 */
+		public function addMimeType(mimetype:String, extensions:Array):void
+		{
+			var newType:Array = [mimetype];
+			for each (var a:String in extensions)
+			{
+				newType.push(a);
+			}
+			types.push(newType);
+		}
+	}
+}
\ No newline at end of file

+/*
+  Copyright (c) 2008, Adobe Systems Incorporated
+  All rights reserved.
+
+  Redistribution and use in source and binary forms, with or without 
+  modification, are permitted provided that the following conditions are
+  met:
+
+  * Redistributions of source code must retain the above copyright notice, 
+    this list of conditions and the following disclaimer.
+  
+  * Redistributions in binary form must reproduce the above copyright
+    notice, this list of conditions and the following disclaimer in the 
+    documentation and/or other materials provided with the distribution.
+  
+  * Neither the name of Adobe Systems Incorporated nor the names of its 
+    contributors may be used to endorse or promote products derived from 
+    this software without specific prior written permission.
+
+  THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS
+  IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO,
+  THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR
+  PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT OWNER OR 
+  CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL,
+  EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO,
+  PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR
+  PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF
+  LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING
+  NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS
+  SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+*/
+
+package com.adobe.net
+{
+	import flash.utils.ByteArray;
+	
+	/**
+	 * This class implements an efficient lookup table for URI
+	 * character escaping.  This class is only needed if you
+	 * create a derived class of URI to handle custom URI
+	 * syntax.  This class is used internally by URI.
+	 * 
+	 * @langversion ActionScript 3.0
+	 * @playerversion Flash 9.0* 
+	 */
+	public class URIEncodingBitmap extends ByteArray
+	{
+		/**
+		 * Constructor.  Creates an encoding bitmap using the given
+		 * string of characters as the set of characters that need
+		 * to be URI escaped.
+		 * 
+		 * @langversion ActionScript 3.0
+		 * @playerversion Flash 9.0
+		 */
+		public function URIEncodingBitmap(charsToEscape:String) : void
+		{
+			var i:int;
+			var data:ByteArray = new ByteArray();
+			
+			// Initialize our 128 bits (16 bytes) to zero
+			for (i = 0; i < 16; i++)
+				this.writeByte(0);
+				
+			data.writeUTFBytes(charsToEscape);
+			data.position = 0;
+			
+			while (data.bytesAvailable)
+			{
+				var c:int = data.readByte();
+				
+				if (c > 0x7f)
+					continue;  // only escape low bytes
+					
+				var enc:int;
+				this.position = (c >> 3);
+				enc = this.readByte();
+				enc |= 1 << (c & 0x7);
+				this.position = (c >> 3);
+				this.writeByte(enc);
+			}
+		}
+		
+		/**
+		 * Based on the data table contained in this object, check
+		 * if the given character should be escaped.
+		 * 
+		 * @param char	the character to be escaped.  Only the first
+		 * character in the string is used.  Any other characters
+		 * are ignored.
+		 * 
+		 * @return	the integer value of the raw UTF8 character.  For
+		 * example, if '%' is given, the return value is 37 (0x25).
+		 * If the character given does not need to be escaped, the
+		 * return value is zero.
+		 * 
+		 * @langversion ActionScript 3.0
+		 * @playerversion Flash 9.0 
+		 */
+		public function ShouldEscape(char:String) : int
+		{
+			var data:ByteArray = new ByteArray();
+			var c:int, mask:int;
+			
+			// write the character into a ByteArray so
+			// we can pull it out as a raw byte value.
+			data.writeUTFBytes(char);
+			data.position = 0;
+			c = data.readByte();
+			
+			if (c & 0x80)
+			{
+				// don't escape high byte characters.  It can make international
+				// URI's unreadable.  We just want to escape characters that would
+				// make URI syntax ambiguous.
+				return 0;
+			}
+			else if ((c < 0x1f) || (c == 0x7f))
+			{
+				// control characters must be escaped.
+				return c;
+			}
+			
+			this.position = (c >> 3);
+			mask = this.readByte();
+			
+			if (mask & (1 << (c & 0x7)))
+			{
+				// we need to escape this, return the numeric value
+				// of the character
+				return c;
+			}
+			else
+			{
+				return 0;
+			}
+		}
+	}
+}
\ No newline at end of file

+/*
+  Copyright (c) 2008, Adobe Systems Incorporated
+  All rights reserved.
+
+  Redistribution and use in source and binary forms, with or without 
+  modification, are permitted provided that the following conditions are
+  met:
+
+  * Redistributions of source code must retain the above copyright notice, 
+    this list of conditions and the following disclaimer.
+  
+  * Redistributions in binary form must reproduce the above copyright
+    notice, this list of conditions and the following disclaimer in the 
+    documentation and/or other materials provided with the distribution.
+  
+  * Neither the name of Adobe Systems Incorporated nor the names of its 
+    contributors may be used to endorse or promote products derived from 
+    this software without specific prior written permission.
+
+  THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS
+  IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO,
+  THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR
+  PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT OWNER OR 
+  CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL,
+  EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO,
+  PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR
+  PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF
+  LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING
+  NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS
+  SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+*/
+package com.adobe.net.proxies
+{
+	import flash.events.Event;
+	import flash.events.IOErrorEvent;
+	import flash.events.ProgressEvent;
+	import flash.net.Socket;
+
+	/**
+	 * This class allows TCP socket connections through HTTP proxies in accordance with
+	 * RFC 2817:
+	 * 
+	 * ftp://ftp.rfc-editor.org/in-notes/rfc2817.txt
+	 * 
+	 * It can also be used to make direct connections to a destination, as well. If you
+	 * pass the host and port into the constructor, no proxy will be used. You can also
+	 * call connect, passing in the host and the port, and if you didn't set the proxy
+	 * info, a direct connection will be made. A proxy is only used after you have called
+	 * the setProxyInfo function.
+	 * 
+	 * The connection to and negotiation with the proxy is completely hidden. All the
+	 * same events are thrown whether you are using a proxy or not, and the data you
+	 * receive from the target server will look exact as it would if you were connected
+	 * to it directly rather than through a proxy.
+	 * 
+	 * @author Christian Cantrell
+	 * 
+	 **/
+	public class RFC2817Socket
+		extends Socket
+	{
+		private var proxyHost:String = null;
+		private var host:String = null;
+		private var proxyPort:int = 0;
+		private var port:int = 0;
+		private var deferredEventHandlers:Object = new Object();
+		private var buffer:String = new String();
+
+		/**
+		 * Construct a new RFC2817Socket object. If you pass in the host and the port,
+		 * no proxy will be used. If you want to use a proxy, instantiate with no
+		 * arguments, call setProxyInfo, then call connect.
+		 **/
+		public function RFC2817Socket(host:String = null, port:int = 0)
+		{
+			super(host, port);
+		}
+		
+		/**
+		 * Set the proxy host and port number. Your connection will only proxied if
+		 * this function has been called.
+		 **/
+		public function setProxyInfo(host:String, port:int):void
+		{
+			this.proxyHost = host;
+			this.proxyPort = port;
+
+			var deferredSocketDataHandler:Object = this.deferredEventHandlers[ProgressEvent.SOCKET_DATA];
+			var deferredConnectHandler:Object = this.deferredEventHandlers[Event.CONNECT];
+
+			if (deferredSocketDataHandler != null)
+			{
+				super.removeEventListener(ProgressEvent.SOCKET_DATA, deferredSocketDataHandler.listener, deferredSocketDataHandler.useCapture);
+			}
+
+			if (deferredConnectHandler != null)
+			{
+				super.removeEventListener(Event.CONNECT, deferredConnectHandler.listener, deferredConnectHandler.useCapture);
+			}
+		}
+		
+		/**
+		 * Connect to the specified host over the specified port. If you want your
+		 * connection proxied, call the setProxyInfo function first.
+		 **/
+		public override function connect(host:String, port:int):void
+		{
+			if (this.proxyHost == null)
+			{
+				this.redirectConnectEvent();
+				this.redirectSocketDataEvent();
+				super.connect(host, port);
+			}
+			else
+			{
+				this.host = host;
+				this.port = port;
+				super.addEventListener(Event.CONNECT, this.onConnect);
+				super.addEventListener(ProgressEvent.SOCKET_DATA, this.onSocketData);
+				super.connect(this.proxyHost, this.proxyPort);
+			}
+		}
+
+		private function onConnect(event:Event):void
+		{
+			this.writeUTFBytes("CONNECT "+this.host+":"+this.port+" HTTP/1.1\n\n");
+			this.flush();
+			this.redirectConnectEvent();
+		}
+		
+		private function onSocketData(event:ProgressEvent):void
+		{
+			while (this.bytesAvailable != 0)
+			{
+				this.buffer += this.readUTFBytes(1);
+				if (this.buffer.search(/\r?\n\r?\n$/) != -1)
+				{
+					this.checkResponse(event);
+					break;
+				}
+			}
+		}
+		
+		private function checkResponse(event:ProgressEvent):void
+		{
+			var responseCode:String = this.buffer.substr(this.buffer.indexOf(" ")+1, 3);
+
+			if (responseCode.search(/^2/) == -1)
+			{
+				var ioError:IOErrorEvent = new IOErrorEvent(IOErrorEvent.IO_ERROR);
+				ioError.text = "Error connecting to the proxy ["+this.proxyHost+"] on port ["+this.proxyPort+"]: " + this.buffer;
+				this.dispatchEvent(ioError);
+			}
+			else
+			{
+				this.redirectSocketDataEvent();
+				this.dispatchEvent(new Event(Event.CONNECT));
+				if (this.bytesAvailable > 0)
+				{
+					this.dispatchEvent(event);
+				}
+			}
+			this.buffer = null;
+		}
+		
+		private function redirectConnectEvent():void
+		{
+			super.removeEventListener(Event.CONNECT, onConnect);
+			var deferredEventHandler:Object = this.deferredEventHandlers[Event.CONNECT];
+			if (deferredEventHandler != null)
+			{
+				super.addEventListener(Event.CONNECT, deferredEventHandler.listener, deferredEventHandler.useCapture, deferredEventHandler.priority, deferredEventHandler.useWeakReference);			
+			}
+		}
+		
+		private function redirectSocketDataEvent():void
+		{
+			super.removeEventListener(ProgressEvent.SOCKET_DATA, onSocketData);
+			var deferredEventHandler:Object = this.deferredEventHandlers[ProgressEvent.SOCKET_DATA];
+			if (deferredEventHandler != null)
+			{
+				super.addEventListener(ProgressEvent.SOCKET_DATA, deferredEventHandler.listener, deferredEventHandler.useCapture, deferredEventHandler.priority, deferredEventHandler.useWeakReference);			
+			}
+		}
+		
+		public override function addEventListener(type:String, listener:Function, useCapture:Boolean = false, priority:int=0.0, useWeakReference:Boolean=false):void
+		{
+			if (type == Event.CONNECT || type == ProgressEvent.SOCKET_DATA)
+			{
+				this.deferredEventHandlers[type] = {listener:listener,useCapture:useCapture, priority:priority, useWeakReference:useWeakReference};
+			}
+			else
+			{
+				super.addEventListener(type, listener, useCapture, priority, useWeakReference);
+			}
+		}
+	}
+}
\ No newline at end of file

+package com.adobe.protocols.dict
+{
+	public class Database
+	{
+		private var _name:String;
+		private var _description:String;
+
+		public function Database(name:String, description:String)
+		{
+			this._name = name;
+			this._description = description;
+		}
+
+		public function set name(name:String):void
+		{
+			this._name = name;
+		}
+
+		public function get name():String
+		{
+			return this._name;
+		}
+
+		public function set description(description:String):void
+		{
+			this._description = description;
+		}
+
+		public function get description():String
+		{
+			return this._description;
+		}
+	}
+}
\ No newline at end of file

+package com.adobe.protocols.dict
+{
+	public class Definition
+	{
+		private var _definition:String;
+		private var _database:String;
+		private var _term:String;
+		
+		public function set definition(definition:String):void
+		{
+			this._definition = definition;
+		}
+		
+		public function get definition():String
+		{
+			return this._definition;
+		}
+
+		public function set database(database:String):void
+		{
+			this._database = database;
+		}
+		
+		public function get database():String
+		{
+			return this._database;
+		}
+
+		public function set term(term:String):void
+		{
+			this._term = term;
+		}
+		
+		public function get term():String
+		{
+			return this._term;
+		}
+	}
+}
\ No newline at end of file

+package com.adobe.protocols.dict
+{
+	import com.adobe.protocols.dict.events.*;
+	import com.adobe.protocols.dict.util.*;
+	
+	import flash.events.Event;
+	import flash.events.EventDispatcher;
+	import flash.events.IOErrorEvent;
+	import flash.events.ProgressEvent;
+	import flash.events.SecurityErrorEvent;
+	import flash.net.Socket;
+	import mx.rpc.http.HTTPService;
+	import mx.rpc.events.ResultEvent;
+	import mx.rpc.events.FaultEvent;
+	import flash.xml.XMLNode;
+	import mx.utils.StringUtil;
+
+	public class Dict
+		extends EventDispatcher
+	{
+		// Event type names.
+		public static var CONNECTED:String = "connected";
+		public static var DISCONNECTED:String = "disconnected";
+		public static var IO_ERROR:String = IOErrorEvent.IO_ERROR;
+		public static var ERROR:String = "error";
+		public static var SERVERS:String = "servers";
+		public static var DATABASES:String = "databases";
+		public static var MATCH_STRATEGIES:String = "matchStrategies";
+		public static var DEFINITION:String = "definition";
+		public static var DEFINITION_HEADER:String = "definitionHeader";
+		public static var MATCH:String = "match";
+		public static var NO_MATCH:String = "noMatch";
+
+		public static var FIRST_MATCH:uint = 0;
+		public static var ALL_DATABASES:uint = 1;
+
+		private var socket:SocketHelper;
+		
+		private var dbShortList:Boolean;
+
+		public function Dict()
+		{
+			this.socket = new SocketHelper();
+			this.socket.addEventListener(Event.CONNECT, connected);
+			this.socket.addEventListener(Event.CLOSE, disconnected);
+			this.socket.addEventListener(SocketHelper.COMPLETE_RESPONSE, incomingData);
+			this.socket.addEventListener(IOErrorEvent.IO_ERROR, ioError);
+			this.socket.addEventListener(SecurityErrorEvent.SECURITY_ERROR, securityError);
+		}
+
+		public function connect(server:String, port:uint = 2628):void
+		{
+			if (this.socket.connected)
+			{
+				this.socket.close();
+			}
+			this.socket.connect(server, port);
+		}
+
+		public function connectThroughProxy(proxyServer:String,
+											proxyPort:int,
+											server:String,
+											port:uint = 2628):void
+		{
+			if (this.socket.connected)
+			{
+				this.socket.close();
+			}
+			this.socket.setProxyInfo(proxyServer, proxyPort);
+			this.socket.connect(server, port);
+		}
+
+		public function disconnect():void
+		{
+			this.socket.close();
+			this.disconnected(null);
+		}
+
+		public function getServers():void
+		{
+			var http:HTTPService = new HTTPService();
+			http.url = "http://luetzschena-stahmeln.de/dictd/xmllist.php";
+			http.addEventListener(ResultEvent.RESULT, incomingServerXML);
+			http.addEventListener(FaultEvent.FAULT, httpError);
+			http.resultFormat = HTTPService.RESULT_FORMAT_E4X;
+			http.send();
+		}
+
+		public function getDatabases(shortList:Boolean=true):void
+		{
+			this.dbShortList = shortList;
+			this.socket.writeUTFBytes("show db\r\n");
+			this.socket.flush();
+		}
+
+		public function getMatchStrategies():void
+		{
+			this.socket.writeUTFBytes("show strat\r\n");
+			this.socket.flush();
+		}
+
+		public function match(database:String, term:String, scope:String="prefix"):void
+		{
+			this.socket.writeUTFBytes("match " + database + " " + scope + " \"" + term + "\"\r\n");
+			this.socket.flush();
+		}
+
+		public function define(database:String, term:String):void
+		{
+			this.socket.writeUTFBytes("define " + database + " \"" + term + "\"\r\n");
+			this.socket.flush();
+		}
+
+		public function lookup(term:String, scope:uint):void
+		{
+			var flag:String;
+			if (scope == Dict.ALL_DATABASES)
+			{
+				flag = "*";
+			}
+			else if (scope == Dict.FIRST_MATCH)
+			{
+				flag = "!";
+			}
+			this.socket.writeUTFBytes("define " + flag + " \"" + term + "\"\r\n");
+			this.socket.flush();
+		}
+
+		//// Private functions ////
+
+		private function connected(event:Event):void
+		{
+        	// Wait to dispatch an event until we get the 220 response.
+    	}
+
+		private function disconnected(event:Event):void
+		{
+        	dispatchEvent(new DisconnectedEvent());
+    	}
+
+		private function incomingServerXML(event:ResultEvent):void
+		{
+			var dictd:Namespace = new Namespace("http://www.luetzschena-stahmeln.de/dictd/");
+			var result:XML = event.result as XML;
+			var server:String, description:String;
+			var servers:Array = new Array();
+			for each (var serverNode:XML in result.dictd::server)
+			{
+				server = serverNode.dictd::dictdurl;
+				description = serverNode.dictd::description;
+				if (StringUtil.trim(server).length != 0 &&
+					StringUtil.trim(description).length != 0)
+				{
+					var dServer:DictionaryServer = new DictionaryServer();
+					dServer.server = server.replace("dict://", "");
+					dServer.description = description;
+					servers.push(dServer);
+				}
+			}
+			var dEvent:DictionaryServerEvent = new DictionaryServerEvent();
+			dEvent.servers = servers;
+			dispatchEvent(dEvent);
+		}
+
+		private function incomingData(event:CompleteResponseEvent):void
+		{			
+			var rawResponse:String = event.response;
+			var response:Response = this.parseRawResponse(rawResponse);
+			var responseCode:uint = response.code;
+			if (responseCode == 552) // no matches
+			{
+				throwNoMatchEvent(response);
+			}
+			else if (responseCode >= 400 && responseCode <= 599) // error
+			{
+				throwErrorEvent(response);
+			}
+			else if (responseCode == 220) // successful connection
+			{
+				dispatchEvent(new ConnectedEvent());
+			}
+			else if (responseCode == 110) // databases are being returned
+			{
+				throwDatabasesEvent(response);				
+			}
+			else if (responseCode == 111) // matches strategies
+			{
+				throwMatchStrategiesEvent(response);
+			}
+			else if (responseCode == 152) // matches
+			{
+				throwMatchEvent(response);
+			}
+			else if (responseCode == 150)
+			{
+				throwDefinitionHeaderEvent(response);
+			}
+			else if (responseCode == 151)
+			{
+				throwDefinitionEvent(response);
+			}
+    	}
+
+    	private function ioError(event:IOErrorEvent):void
+    	{
+			dispatchEvent(event);
+    	}
+
+    	private function httpError(event:FaultEvent):void
+    	{
+    		trace("httpError!");
+    	}
+
+    	private function securityError(event:SecurityErrorEvent):void
+    	{
+    		trace("security error!");
+    		trace(event.text);
+    	}
+
+    	// Dispatch new events.
+
+    	private function throwDatabasesEvent(response:Response):void
+    	{
+			var databases:Array = new Array();
+			var responseArray:Array = response.body.split("\r\n");
+    		for each (var line:String in responseArray)
+    		{
+    			var name:String = line.substring(0, line.indexOf(" "));
+    			if (name == "--exit--")
+    			{
+    				if (this.dbShortList)
+    				{
+    					break;
+    				}
+    				continue;
+    			}
+    			var description:String = line.substring(line.indexOf(" ")+1, line.length).replace(/\"/g,"");
+    			databases.push(new Database(name, description));
+    		}
+    		var event:DatabaseEvent = new DatabaseEvent();
+    		event.databases = databases;
+    		dispatchEvent(event);
+    	}
+
+    	private function throwMatchStrategiesEvent(response:Response):void
+    	{
+			var strategies:Array = new Array();
+			var responseArray:Array = response.body.split("\r\n");
+    		for each (var line:String in responseArray)
+    		{
+    			var name:String = line.substring(0, line.indexOf(" "));
+    			var description:String = line.substring(line.indexOf(" ")+1, line.length).replace(/\"/g,"");
+    			strategies.push(new MatchStrategy(name, description));
+    		}
+    		var event:MatchStrategiesEvent = new MatchStrategiesEvent();
+    		event.strategies = strategies;
+    		dispatchEvent(event);
+    	}
+
+    	private function throwMatchEvent(response:Response):void
+    	{
+			var matches:Array = new Array();
+			var responseArray:Array = response.body.split("\r\n");
+    		for each (var line:String in responseArray)
+    		{
+    			var match:String = line.substring(line.indexOf(" ")+1, line.length).replace(/\"/g,"");
+    			matches.push(match);
+    		}
+    		var event:MatchEvent = new MatchEvent();
+    		event.matches = matches;
+    		dispatchEvent(event);
+    	}
+
+    	private function throwErrorEvent(response:Response):void
+    	{
+    		var event:ErrorEvent = new ErrorEvent();
+    		event.code = response.code;
+    		event.message = response.headerText;
+			dispatchEvent(event);
+    	}
+
+    	private function throwNoMatchEvent(response:Response):void
+    	{
+			dispatchEvent(new NoMatchEvent());
+    	}
+
+    	private function throwDefinitionHeaderEvent(response:Response):void
+    	{
+			var event:DefinitionHeaderEvent = new DefinitionHeaderEvent();
+			event.definitionCount = uint(response.headerText.substring(0, response.headerText.indexOf(" ")));
+			dispatchEvent(event);
+    	}
+
+    	private function throwDefinitionEvent(response:Response):void
+    	{
+    		var event:DefinitionEvent = new DefinitionEvent();
+    		var def:Definition = new Definition();
+    		var headerText:String = response.headerText;
+    		var tokens:Array = headerText.match(/"[^"]+"/g);
+    		def.term = String(tokens[0]).replace(/"/g, "");
+    		def.database = String(tokens[1]).replace(/"/g, "");
+    		def.definition = response.body;
+    		event.definition = def;
+			dispatchEvent(event);
+    	}
+
+    	private function parseRawResponse(rawResponse:String):Response
+    	{
+    		var response:Response = new Response();
+    		var fullHeader:String;
+    		if (rawResponse.indexOf("\r\n") != -1)
+    		{
+	    		fullHeader = rawResponse.substring(0, rawResponse.indexOf("\r\n"));
+    		}
+    		else
+    		{
+    			fullHeader = rawResponse;
+    		}
+      		var responseCodeMatch:Array = fullHeader.match(/^\d{3}/);
+    		response.code = uint(responseCodeMatch[0]);
+    		response.headerText = fullHeader.substring(fullHeader.indexOf(" ")+1, fullHeader.length);
+			var body:String = rawResponse.substring(rawResponse.indexOf("\r\n")+2, rawResponse.length);
+			body = body.replace(/\r\n\.\./, "\r\n.");
+			response.body = body;
+    		return response;
+    	}
+	}
+}
\ No newline at end of file

+package com.adobe.protocols.dict
+{
+	public class DictionaryServer
+	{
+		private var _server:String;
+		private var _description:String;
+
+		public function set server(server:String):void
+		{
+			this._server = server;
+		}
+		
+		public function get server():String
+		{
+			return this._server;
+		}
+
+		public function set description(description:String):void
+		{
+			this._description = description;
+		}
+		
+		public function get description():String
+		{
+			return this._description;
+		}
+	}
+}
\ No newline at end of file

+package com.adobe.protocols.dict
+{
+	public class MatchStrategy
+	{
+		private var _name:String;
+		private var _description:String;
+
+		public function MatchStrategy(name:String, description:String)
+		{
+			this._name = name;
+			this._description = description;
+		}
+
+		public function set name(name:String):void
+		{
+			this._name = name;
+		}
+
+		public function get name():String
+		{
+			return this._name;
+		}
+
+		public function set description(description:String):void
+		{
+			this._description = description;
+		}
+
+		public function get description():String
+		{
+			return this._description;
+		}
+	}
+}
\ No newline at end of file

+package com.adobe.protocols.dict
+{
+	public class Response
+	{
+		private var _code:uint;
+		private var _headerText:String;
+		private var _body:String;
+
+		public function set code(code:uint):void
+		{
+			this._code = code;
+		}
+
+		public function set headerText(headerText:String):void
+		{
+			this._headerText = headerText;
+		}
+
+		public function set body(body:String):void
+		{
+			this._body = body;
+		}
+
+		public function get code():uint
+		{
+			return this._code;
+		}
+
+		public function get headerText():String
+		{
+			return this._headerText;
+		}
+
+		public function get body():String
+		{
+			return this._body;
+		}
+	}
+}
\ No newline at end of file

+package com.adobe.protocols.dict.events
+{
+	import flash.events.Event;
+	import com.adobe.protocols.dict.Dict;
+
+	public class ConnectedEvent extends Event
+	{
+		public function ConnectedEvent()
+		{
+			super(Dict.CONNECTED);
+		}
+		
+	}
+}
\ No newline at end of file

+package com.adobe.protocols.dict.events
+{
+	import flash.events.Event;
+	import com.adobe.protocols.dict.Dict;
+
+	public class DatabaseEvent
+		extends Event
+	{
+		private var _databases:Array;
+		
+		public function DatabaseEvent()
+		{
+			super(Dict.DATABASES);
+		}
+		
+		public function set databases(databases:Array):void
+		{
+			this._databases = databases;
+		}
+		
+		public function get databases():Array
+		{
+			return this._databases;
+		}
+	}
+}
\ No newline at end of file

+package com.adobe.protocols.dict.events
+{
+	import flash.events.Event;
+	import com.adobe.protocols.dict.Dict;
+	import com.adobe.protocols.dict.Definition;
+
+	public class DefinitionEvent
+		extends Event
+	{
+		private var _definition:Definition;
+		
+		public function DefinitionEvent()
+		{
+			super(Dict.DEFINITION);
+		}
+		
+		public function set definition(definition:Definition):void
+		{
+			this._definition = definition;
+		}
+		
+		public function get definition():Definition
+		{
+			return this._definition;
+		}
+	}
+}
\ No newline at end of file

+package com.adobe.protocols.dict.events
+{
+	import flash.events.Event;
+	import com.adobe.protocols.dict.Dict;
+
+	public class DefinitionHeaderEvent
+		extends Event
+	{
+		private var _definitionCount:uint;
+		
+		public function DefinitionHeaderEvent()
+		{
+			super(Dict.DEFINITION_HEADER);
+		}
+		
+		public function set definitionCount(definitionCount:uint):void
+		{
+			this._definitionCount = definitionCount;
+		}
+		
+		public function get definitionCount():uint
+		{
+			return this._definitionCount;
+		}
+	}
+}
\ No newline at end of file

+package com.adobe.protocols.dict.events
+{
+	import flash.events.Event;
+	import com.adobe.protocols.dict.Dict;
+
+	public class DictionaryServerEvent
+		extends Event
+	{
+		private var _servers:Array;
+		
+		public function DictionaryServerEvent()
+		{
+			super(Dict.SERVERS);
+		}
+		
+		public function set servers(servers:Array):void
+		{
+			this._servers = servers;
+		}
+		
+		public function get servers():Array
+		{
+			return this._servers;
+		}
+	}
+}
\ No newline at end of file

+package com.adobe.protocols.dict.events
+{
+	import flash.events.Event;
+	import com.adobe.protocols.dict.Dict;
+
+	public class DisconnectedEvent extends Event
+	{
+		public function DisconnectedEvent()
+		{
+			super(Dict.DISCONNECTED);
+		}
+		
+	}
+}
\ No newline at end of file

+package com.adobe.protocols.dict.events
+{
+	import flash.events.Event;
+	import com.adobe.protocols.dict.Dict;
+	
+	public class ErrorEvent
+		extends Event
+	{
+		private var _code:uint;
+		private var _message:String;
+		
+		public function ErrorEvent()
+		{
+			super(Dict.ERROR);
+		}
+
+		public function set code(code:uint):void
+		{
+			this._code = code;
+		}
+
+		public function set message(message:String):void
+		{
+			this._message = message;
+		}
+
+		public function get code():uint
+		{
+			return this._code;
+		}
+
+		public function get message():String
+		{
+			return this._message;
+		}
+	}
+}
\ No newline at end of file

+package com.adobe.protocols.dict.events
+{
+	import flash.events.Event;
+	import com.adobe.protocols.dict.Dict;
+
+	public class MatchEvent
+		extends Event
+	{
+		private var _matches:Array;
+		
+		public function MatchEvent()
+		{
+			super(Dict.MATCH);
+		}
+		
+		public function set matches(matches:Array):void
+		{
+			this._matches = matches;
+		}
+		
+		public function get matches():Array
+		{
+			return this._matches;
+		}
+	}
+}
\ No newline at end of file

+package com.adobe.protocols.dict.events
+{
+	import flash.events.Event;
+	import com.adobe.protocols.dict.Dict;
+
+	public class MatchStrategiesEvent
+		extends Event
+	{
+		private var _strategies:Array;
+		
+		public function MatchStrategiesEvent()
+		{
+			super(Dict.MATCH_STRATEGIES);
+		}
+		
+		public function set strategies(strategies:Array):void
+		{
+			this._strategies = strategies;
+		}
+		
+		public function get strategies():Array
+		{
+			return this._strategies;
+		}
+	}
+}
\ No newline at end of file

+package com.adobe.protocols.dict.events
+{
+	import flash.events.Event;
+	import com.adobe.protocols.dict.Dict;
+
+	public class NoMatchEvent
+		extends Event
+	{
+		public function NoMatchEvent()
+		{
+			super(Dict.NO_MATCH);
+		}
+	}
+}
\ No newline at end of file

+package com.adobe.protocols.dict.util
+{
+	import flash.events.Event;
+
+	public class CompleteResponseEvent
+		extends Event
+	{
+		private var _response:String;
+
+		public function CompleteResponseEvent()
+		{
+			super(SocketHelper.COMPLETE_RESPONSE);
+		}
+
+		public function set response(response:String):void
+		{
+			this._response = response;
+		}
+		
+		public function get response():String
+		{
+			return this._response;
+		}
+	}
+}
\ No newline at end of file

+package com.adobe.protocols.dict.util
+{
+	import com.adobe.net.proxies.RFC2817Socket;
+	import flash.events.ProgressEvent;
+
+	public class SocketHelper
+		extends RFC2817Socket
+	{
+		private var terminator:String = "\r\n.\r\n";
+		private var buffer:String;
+		public static var COMPLETE_RESPONSE:String = "completeResponse";
+
+		public function SocketHelper()
+		{
+			super();
+			buffer = new String();
+			addEventListener(ProgressEvent.SOCKET_DATA, incomingData);
+		}
+
+		private function incomingData(event:ProgressEvent):void
+		{
+			buffer += readUTFBytes(bytesAvailable);
+			buffer = buffer.replace(/250[^\r\n]+\r\n/, ""); // Get rid of all 250s. Don't need them.
+			var codeStr:String = buffer.substring(0, 3);
+			if (!isNaN(parseInt(codeStr)))
+			{
+				var code:uint = uint(codeStr);
+				if (code == 150 || code >= 200)
+				{
+					buffer = buffer.replace("\r\n", this.terminator);
+				}
+			}
+
+			while (buffer.indexOf(this.terminator) != -1)
+			{
+				var chunk:String = buffer.substring(0, buffer.indexOf(this.terminator));
+				buffer = buffer.substring(chunk.length + this.terminator.length, buffer.length);
+				throwResponseEvent(chunk);
+			}
+		}
+		
+		private function throwResponseEvent(response:String):void
+		{
+			var responseEvent:CompleteResponseEvent = new CompleteResponseEvent();
+			responseEvent.response = response;
+			dispatchEvent(responseEvent);			
+		}
+	}
+}
\ No newline at end of file

+/*
+  Copyright (c) 2008, Adobe Systems Incorporated
+  All rights reserved.
+
+  Redistribution and use in source and binary forms, with or without 
+  modification, are permitted provided that the following conditions are
+  met:
+
+  * Redistributions of source code must retain the above copyright notice, 
+    this list of conditions and the following disclaimer.
+  
+  * Redistributions in binary form must reproduce the above copyright
+    notice, this list of conditions and the following disclaimer in the 
+    documentation and/or other materials provided with the distribution.
+  
+  * Neither the name of Adobe Systems Incorporated nor the names of its 
+    contributors may be used to endorse or promote products derived from 
+    this software without specific prior written permission.
+
+  THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS
+  IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO,
+  THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR
+  PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT OWNER OR 
+  CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL,
+  EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO,
+  PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR
+  PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF
+  LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING
+  NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS
+  SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+*/
+
+package com.adobe.serialization.json {
+
+	/**
+	 * This class provides encoding and decoding of the JSON format.
+	 *
+	 * Example usage:
+	 * <code>
+	 * 		// create a JSON string from an internal object
+	 * 		JSON.encode( myObject );
+	 *
+	 *		// read a JSON string into an internal object
+	 *		var myObject:Object = JSON.decode( jsonString );
+	 *	</code>
+	 */
+	public class JSON {
+	
+	
+		/**
+		 * Encodes a object into a JSON string.
+		 *
+		 * @param o The object to create a JSON string for
+		 * @return the JSON string representing o
+		 * @langversion ActionScript 3.0
+		 * @playerversion Flash 9.0
+		 * @tiptext
+		 */
+		public static function encode( o:Object ):String {
+			
+			var encoder:JSONEncoder = new JSONEncoder( o );
+			return encoder.getString();
+		
+		}
+		
+		/**
+		 * Decodes a JSON string into a native object.
+		 * 
+		 * @param s The JSON string representing the object
+		 * @return A native object as specified by s
+		 * @throw JSONParseError
+		 * @langversion ActionScript 3.0
+		 * @playerversion Flash 9.0
+		 * @tiptext
+		 */
+		public static function decode( s:String ):* {
+			
+			var decoder:JSONDecoder = new JSONDecoder( s )
+			return decoder.getValue();
+			
+		}
+	
+	}
+
+}
\ No newline at end of file

+/*
+  Copyright (c) 2008, Adobe Systems Incorporated
+  All rights reserved.
+
+  Redistribution and use in source and binary forms, with or without 
+  modification, are permitted provided that the following conditions are
+  met:
+
+  * Redistributions of source code must retain the above copyright notice, 
+    this list of conditions and the following disclaimer.
+  
+  * Redistributions in binary form must reproduce the above copyright
+    notice, this list of conditions and the following disclaimer in the 
+    documentation and/or other materials provided with the distribution.
+  
+  * Neither the name of Adobe Systems Incorporated nor the names of its 
+    contributors may be used to endorse or promote products derived from 
+    this software without specific prior written permission.
+
+  THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS
+  IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO,
+  THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR
+  PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT OWNER OR 
+  CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL,
+  EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO,
+  PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR
+  PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF
+  LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING
+  NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS
+  SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+*/
+
+package com.adobe.serialization.json {
+
+	public class JSONDecoder {
+		
+		/** The value that will get parsed from the JSON string */
+		private var value:*;
+		
+		/** The tokenizer designated to read the JSON string */
+		private var tokenizer:JSONTokenizer;
+		
+		/** The current token from the tokenizer */
+		private var token:JSONToken;
+		
+		/**
+		 * Constructs a new JSONDecoder to parse a JSON string 
+		 * into a native object.
+		 *
+		 * @param s The JSON string to be converted
+		 *		into a native object
+		 * @langversion ActionScript 3.0
+		 * @playerversion Flash 9.0
+		 * @tiptext
+		 */
+		public function JSONDecoder( s:String ) {
+			
+			tokenizer = new JSONTokenizer( s );
+			
+			nextToken();
+			value = parseValue();
+		}
+		
+		/**
+		 * Gets the internal object that was created by parsing
+		 * the JSON string passed to the constructor.
+		 *
+		 * @return The internal object representation of the JSON
+		 * 		string that was passed to the constructor
+		 * @langversion ActionScript 3.0
+		 * @playerversion Flash 9.0
+		 * @tiptext
+		 */
+		public function getValue():* {
+			return value;
+		}
+		
+		/**
+		 * Returns the next token from the tokenzier reading
+		 * the JSON string
+		 */
+		private function nextToken():JSONToken {
+			return token = tokenizer.getNextToken();
+		}
+		
+		/**
+		 * Attempt to parse an array
+		 */
+		private function parseArray():Array {
+			// create an array internally that we're going to attempt
+			// to parse from the tokenizer
+			var a:Array = new Array();
+			
+			// grab the next token from the tokenizer to move
+			// past the opening [
+			nextToken();
+			
+			// check to see if we have an empty array
+			if ( token.type == JSONTokenType.RIGHT_BRACKET ) {
+				// we're done reading the array, so return it
+				return a;
+			}
+			
+			// deal with elements of the array, and use an "infinite"
+			// loop because we could have any amount of elements
+			while ( true ) {
+				// read in the value and add it to the array
+				a.push ( parseValue() );
+			
+				// after the value there should be a ] or a ,
+				nextToken();
+				
+				if ( token.type == JSONTokenType.RIGHT_BRACKET ) {
+					// we're done reading the array, so return it
+					return a;
+				} else if ( token.type == JSONTokenType.COMMA ) {
+					// move past the comma and read another value
+					nextToken();
+				} else {
+					tokenizer.parseError( "Expecting ] or , but found " + token.value );
+				}
+			}
+            return null;
+		}
+		
+		/**
+		 * Attempt to parse an object
+		 */
+		private function parseObject():Object {
+			// create the object internally that we're going to
+			// attempt to parse from the tokenizer
+			var o:Object = new Object();
+						
+			// store the string part of an object member so
+			// that we can assign it a value in the object
+			var key:String
+			
+			// grab the next token from the tokenizer
+			nextToken();
+			
+			// check to see if we have an empty object
+			if ( token.type == JSONTokenType.RIGHT_BRACE ) {
+				// we're done reading the object, so return it
+				return o;
+			}
+			
+			// deal with members of the object, and use an "infinite"
+			// loop because we could have any amount of members
+			while ( true ) {
+			
+				if ( token.type == JSONTokenType.STRING ) {
+					// the string value we read is the key for the object
+					key = String( token.value );
+					
+					// move past the string to see what's next
+					nextToken();
+					
+					// after the string there should be a :
+					if ( token.type == JSONTokenType.COLON ) {
+						
+						// move past the : and read/assign a value for the key
+						nextToken();
+						o[key] = parseValue();	
+						
+						// move past the value to see what's next
+						nextToken();
+						
+						// after the value there's either a } or a ,
+						if ( token.type == JSONTokenType.RIGHT_BRACE ) {
+							// // we're done reading the object, so return it
+							return o;
+							
+						} else if ( token.type == JSONTokenType.COMMA ) {
+							// skip past the comma and read another member
+							nextToken();
+						} else {
+							tokenizer.parseError( "Expecting } or , but found " + token.value );
+						}
+					} else {
+						tokenizer.parseError( "Expecting : but found " + token.value );
+					}
+				} else {
+					tokenizer.parseError( "Expecting string but found " + token.value );
+				}
+			}
+            return null;
+		}
+		
+		/**
+		 * Attempt to parse a value
+		 */
+		private function parseValue():Object
+		{
+			// Catch errors when the input stream ends abruptly
+			if ( token == null )
+			{
+				tokenizer.parseError( "Unexpected end of input" );
+			}
+					
+			switch ( token.type ) {
+				case JSONTokenType.LEFT_BRACE:
+					return parseObject();
+					
+				case JSONTokenType.LEFT_BRACKET:
+					return parseArray();
+					
+				case JSONTokenType.STRING:
+				case JSONTokenType.NUMBER:
+				case JSONTokenType.TRUE:
+				case JSONTokenType.FALSE:
+				case JSONTokenType.NULL:
+					return token.value;
+
+				default:
+					tokenizer.parseError( "Unexpected " + token.value );
+					
+			}
+            return null;
+		}
+	}
+}

+/*
+  Copyright (c) 2008, Adobe Systems Incorporated
+  All rights reserved.
+
+  Redistribution and use in source and binary forms, with or without 
+  modification, are permitted provided that the following conditions are
+  met:
+
+  * Redistributions of source code must retain the above copyright notice, 
+    this list of conditions and the following disclaimer.
+  
+  * Redistributions in binary form must reproduce the above copyright
+    notice, this list of conditions and the following disclaimer in the 
+    documentation and/or other materials provided with the distribution.
+  
+  * Neither the name of Adobe Systems Incorporated nor the names of its 
+    contributors may be used to endorse or promote products derived from 
+    this software without specific prior written permission.
+
+  THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS
+  IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO,
+  THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR
+  PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT OWNER OR 
+  CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL,
+  EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO,
+  PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR
+  PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF
+  LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING
+  NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS
+  SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+*/
+
+package com.adobe.serialization.json 
+{
+
+	import flash.utils.describeType;
+
+	public class JSONEncoder {
+	
+		/** The string that is going to represent the object we're encoding */
+		private var jsonString:String;
+		
+		/**
+		 * Creates a new JSONEncoder.
+		 *
+		 * @param o The object to encode as a JSON string
+		 * @langversion ActionScript 3.0
+		 * @playerversion Flash 9.0
+		 * @tiptext
+		 */
+		public function JSONEncoder( value:* ) {
+			jsonString = convertToString( value );
+		
+		}
+		
+		/**
+		 * Gets the JSON string from the encoder.
+		 *
+		 * @return The JSON string representation of the object
+		 * 		that was passed to the constructor
+		 * @langversion ActionScript 3.0
+		 * @playerversion Flash 9.0
+		 * @tiptext
+		 */
+		public function getString():String {
+			return jsonString;
+		}
+		
+		/**
+		 * Converts a value to it's JSON string equivalent.
+		 *
+		 * @param value The value to convert.  Could be any 
+		 *		type (object, number, array, etc)
+		 */
+		private function convertToString( value:* ):String {
+			
+			// determine what value is and convert it based on it's type
+			if ( value is String ) {
+				
+				// escape the string so it's formatted correctly
+				return escapeString( value as String );
+				
+			} else if ( value is Number ) {
+				
+				// only encode numbers that finate
+				return isFinite( value as Number) ? value.toString() : "null";
+
+			} else if ( value is Boolean ) {
+				
+				// convert boolean to string easily
+				return value ? "true" : "false";
+
+			} else if ( value is Array ) {
+			
+				// call the helper method to convert an array
+				return arrayToString( value as Array );
+			
+			} else if ( value is Object && value != null ) {
+			
+				// call the helper method to convert an object
+				return objectToString( value );
+			}
+            return "null";
+		}
+		
+		/**
+		 * Escapes a string accoding to the JSON specification.
+		 *
+		 * @param str The string to be escaped
+		 * @return The string with escaped special characters
+		 * 		according to the JSON specification
+		 */
+		private function escapeString( str:String ):String {
+			// create a string to store the string's jsonstring value
+			var s:String = "";
+			// current character in the string we're processing
+			var ch:String;
+			// store the length in a local variable to reduce lookups
+			var len:Number = str.length;
+			
+			// loop over all of the characters in the string
+			for ( var i:int = 0; i < len; i++ ) {
+			
+				// examine the character to determine if we have to escape it
+				ch = str.charAt( i );
+				switch ( ch ) {
+				
+					case '"':	// quotation mark
+						s += "\\\"";
+						break;
+						
+					//case '/':	// solidus
+					//	s += "\\/";
+					//	break;
+						
+					case '\\':	// reverse solidus
+						s += "\\\\";
+						break;
+						
+					case '\b':	// bell
+						s += "\\b";
+						break;
+						
+					case '\f':	// form feed
+						s += "\\f";
+						break;
+						
+					case '\n':	// newline
+						s += "\\n";
+						break;
+						
+					case '\r':	// carriage return
+						s += "\\r";
+						break;
+						
+					case '\t':	// horizontal tab
+						s += "\\t";
+						break;
+						
+					default:	// everything else
+						
+						// check for a control character and escape as unicode
+						if ( ch < ' ' ) {
+							// get the hex digit(s) of the character (either 1 or 2 digits)
+							var hexCode:String = ch.charCodeAt( 0 ).toString( 16 );
+							
+							// ensure that there are 4 digits by adjusting
+							// the # of zeros accordingly.
+							var zeroPad:String = hexCode.length == 2 ? "00" : "000";
+							
+							// create the unicode escape sequence with 4 hex digits
+							s += "\\u" + zeroPad + hexCode;
+						} else {
+						
+							// no need to do any special encoding, just pass-through
+							s += ch;
+							
+						}
+				}	// end switch
+				
+			}	// end for loop
+						
+			return "\"" + s + "\"";
+		}
+		
+		/**
+		 * Converts an array to it's JSON string equivalent
+		 *
+		 * @param a The array to convert
+		 * @return The JSON string representation of <code>a</code>
+		 */
+		private function arrayToString( a:Array ):String {
+			// create a string to store the array's jsonstring value
+			var s:String = "";
+			
+			// loop over the elements in the array and add their converted
+			// values to the string
+			for ( var i:int = 0; i < a.length; i++ ) {
+				// when the length is 0 we're adding the first element so
+				// no comma is necessary
+				if ( s.length > 0 ) {
+					// we've already added an element, so add the comma separator
+					s += ","
+				}
+				
+				// convert the value to a string
+				s += convertToString( a[i] );	
+			}
+			
+			// KNOWN ISSUE:  In ActionScript, Arrays can also be associative
+			// objects and you can put anything in them, ie:
+			//		myArray["foo"] = "bar";
+			//
+			// These properties aren't picked up in the for loop above because
+			// the properties don't correspond to indexes.  However, we're
+			// sort of out luck because the JSON specification doesn't allow
+			// these types of array properties.
+			//
+			// So, if the array was also used as an associative object, there
+			// may be some values in the array that don't get properly encoded.
+			//
+			// A possible solution is to instead encode the Array as an Object
+			// but then it won't get decoded correctly (and won't be an
+			// Array instance)
+						
+			// close the array and return it's string value
+			return "[" + s + "]";
+		}
+		
+		/**
+		 * Converts an object to it's JSON string equivalent
+		 *
+		 * @param o The object to convert
+		 * @return The JSON string representation of <code>o</code>
+		 */
+		private function objectToString( o:Object ):String
+		{
+			// create a string to store the object's jsonstring value
+			var s:String = "";
+			
+			// determine if o is a class instance or a plain object
+			var classInfo:XML = describeType( o );
+			if ( classInfo.@name.toString() == "Object" )
+			{
+				// the value of o[key] in the loop below - store this 
+				// as a variable so we don't have to keep looking up o[key]
+				// when testing for valid values to convert
+				var value:Object;
+				
+				// loop over the keys in the object and add their converted
+				// values to the string
+				for ( var key:String in o )
+				{
+					// assign value to a variable for quick lookup
+					value = o[key];
+					
+					// don't add function's to the JSON string
+					if ( value is Function )
+					{
+						// skip this key and try another
+						continue;
+					}
+					
+					// when the length is 0 we're adding the first item so
+					// no comma is necessary
+					if ( s.length > 0 ) {
+						// we've already added an item, so add the comma separator
+						s += ","
+					}
+					
+					s += escapeString( key ) + ":" + convertToString( value );
+				}
+			}
+			else // o is a class instance
+			{
+				// Loop over all of the variables and accessors in the class and 
+				// serialize them along with their values.
+				for each ( var v:XML in classInfo..*.( name() == "variable" || name() == "accessor" ) )
+				{
+					// When the length is 0 we're adding the first item so
+					// no comma is necessary
+					if ( s.length > 0 ) {
+						// We've already added an item, so add the comma separator
+						s += ","
+					}
+					
+					s += escapeString( v.@name.toString() ) + ":" 
+							+ convertToString( o[ v.@name ] );
+				}
+				
+			}
+			
+			return "{" + s + "}";
+		}
+
+		
+	}
+	
+}

+/*
+  Copyright (c) 2008, Adobe Systems Incorporated
+  All rights reserved.
+
+  Redistribution and use in source and binary forms, with or without 
+  modification, are permitted provided that the following conditions are
+  met:
+
+  * Redistributions of source code must retain the above copyright notice, 
+    this list of conditions and the following disclaimer.
+  
+  * Redistributions in binary form must reproduce the above copyright
+    notice, this list of conditions and the following disclaimer in the 
+    documentation and/or other materials provided with the distribution.
+  
+  * Neither the name of Adobe Systems Incorporated nor the names of its 
+    contributors may be used to endorse or promote products derived from 
+    this software without specific prior written permission.
+
+  THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS
+  IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO,
+  THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR
+  PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT OWNER OR 
+  CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL,
+  EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO,
+  PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR
+  PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF
+  LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING
+  NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS
+  SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+*/
+
+package com.adobe.serialization.json {
+
+	/**
+	 *
+	 *
+	 */
+	public class JSONParseError extends Error 	{
+	
+		/** The location in the string where the error occurred */
+		private var _location:int;
+		
+		/** The string in which the parse error occurred */
+		private var _text:String;
+	
+		/**
+		 * Constructs a new JSONParseError.
+		 *
+		 * @param message The error message that occured during parsing
+		 * @langversion ActionScript 3.0
+		 * @playerversion Flash 9.0
+		 * @tiptext
+		 */
+		public function JSONParseError( message:String = "", location:int = 0, text:String = "") {
+			super( message );
+			name = "JSONParseError";
+			_location = location;
+			_text = text;
+		}
+
+		/**
+		 * Provides read-only access to the location variable.
+		 *
+		 * @return The location in the string where the error occurred
+		 * @langversion ActionScript 3.0
+		 * @playerversion Flash 9.0
+		 * @tiptext
+		 */
+		public function get location():int {
+			return _location;
+		}
+		
+		/**
+		 * Provides read-only access to the text variable.
+		 *
+		 * @return The string in which the error occurred
+		 * @langversion ActionScript 3.0
+		 * @playerversion Flash 9.0
+		 * @tiptext
+		 */
+		public function get text():String {
+			return _text;
+		}
+	}
+	
+}
\ No newline at end of file

+/*
+  Copyright (c) 2008, Adobe Systems Incorporated
+  All rights reserved.
+
+  Redistribution and use in source and binary forms, with or without 
+  modification, are permitted provided that the following conditions are
+  met:
+
+  * Redistributions of source code must retain the above copyright notice, 
+    this list of conditions and the following disclaimer.
+  
+  * Redistributions in binary form must reproduce the above copyright
+    notice, this list of conditions and the following disclaimer in the 
+    documentation and/or other materials provided with the distribution.
+  
+  * Neither the name of Adobe Systems Incorporated nor the names of its 
+    contributors may be used to endorse or promote products derived from 
+    this software without specific prior written permission.
+
+  THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS
+  IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO,
+  THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR
+  PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT OWNER OR 
+  CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL,
+  EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO,
+  PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR
+  PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF
+  LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING
+  NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS
+  SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+*/
+
+package com.adobe.serialization.json {
+
+	public class JSONToken {
+	
+		private var _type:int;
+		private var _value:Object;
+		
+		/**
+		 * Creates a new JSONToken with a specific token type and value.
+		 *
+		 * @param type The JSONTokenType of the token
+		 * @param value The value of the token
+		 * @langversion ActionScript 3.0
+		 * @playerversion Flash 9.0
+		 * @tiptext
+		 */
+		public function JSONToken( type:int = -1 /* JSONTokenType.UNKNOWN */, value:Object = null ) {
+			_type = type;
+			_value = value;
+		}
+		
+		/**
+		 * Returns the type of the token.
+		 *
+		 * @see com.adobe.serialization.json.JSONTokenType
+		 * @langversion ActionScript 3.0
+		 * @playerversion Flash 9.0
+		 * @tiptext
+		 */
+		public function get type():int {
+			return _type;	
+		}
+		
+		/**
+		 * Sets the type of the token.
+		 *
+		 * @see com.adobe.serialization.json.JSONTokenType
+		 * @langversion ActionScript 3.0
+		 * @playerversion Flash 9.0
+		 * @tiptext
+		 */
+		public function set type( value:int ):void {
+			_type = value;	
+		}
+		
+		/**
+		 * Gets the value of the token
+		 *
+		 * @see com.adobe.serialization.json.JSONTokenType
+		 * @langversion ActionScript 3.0
+		 * @playerversion Flash 9.0
+		 * @tiptext
+		 */
+		public function get value():Object {
+			return _value;	
+		}
+		
+		/**
+		 * Sets the value of the token
+		 *
+		 * @see com.adobe.serialization.json.JSONTokenType
+		 * @langversion ActionScript 3.0
+		 * @playerversion Flash 9.0
+		 * @tiptext
+		 */
+		public function set value ( v:Object ):void {
+			_value = v;	
+		}
+
+	}
+	
+}
\ No newline at end of file

+/*
+  Copyright (c) 2008, Adobe Systems Incorporated
+  All rights reserved.
+
+  Redistribution and use in source and binary forms, with or without 
+  modification, are permitted provided that the following conditions are
+  met:
+
+  * Redistributions of source code must retain the above copyright notice, 
+    this list of conditions and the following disclaimer.
+  
+  * Redistributions in binary form must reproduce the above copyright
+    notice, this list of conditions and the following disclaimer in the 
+    documentation and/or other materials provided with the distribution.
+  
+  * Neither the name of Adobe Systems Incorporated nor the names of its 
+    contributors may be used to endorse or promote products derived from 
+    this software without specific prior written permission.
+
+  THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS
+  IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO,
+  THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR
+  PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT OWNER OR 
+  CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL,
+  EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO,
+  PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR
+  PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF
+  LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING
+  NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS
+  SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+*/
+
+package com.adobe.serialization.json {
+
+	/**
+	 * Class containing constant values for the different types
+	 * of tokens in a JSON encoded string.
+	 */
+	public class JSONTokenType {
+	
+		public static const UNKNOWN:int = -1;
+		
+		public static const COMMA:int = 0;
+		
+		public static const LEFT_BRACE:int = 1;
+		
+		public static const RIGHT_BRACE:int = 2;
+		
+		public static const LEFT_BRACKET:int = 3;
+		
+		public static const RIGHT_BRACKET:int = 4;
+		
+		public static const COLON:int = 6;
+		
+		public static const TRUE:int = 7;
+		
+		public static const FALSE:int = 8;
+		
+		public static const NULL:int = 9;
+		
+		public static const STRING:int = 10;
+		
+		public static const NUMBER:int = 11;
+		
+	}
+	
+}
\ No newline at end of file

+/*
+  Copyright (c) 2008, Adobe Systems Incorporated
+  All rights reserved.
+
+  Redistribution and use in source and binary forms, with or without 
+  modification, are permitted provided that the following conditions are
+  met:
+
+  * Redistributions of source code must retain the above copyright notice, 
+    this list of conditions and the following disclaimer.
+  
+  * Redistributions in binary form must reproduce the above copyright
+    notice, this list of conditions and the following disclaimer in the 
+    documentation and/or other materials provided with the distribution.
+  
+  * Neither the name of Adobe Systems Incorporated nor the names of its 
+    contributors may be used to endorse or promote products derived from 
+    this software without specific prior written permission.
+
+  THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS
+  IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO,
+  THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR
+  PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT OWNER OR 
+  CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL,
+  EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO,
+  PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR
+  PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF
+  LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING
+  NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS
+  SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+*/
+
+package com.adobe.utils
+{
+	
+	/**
+	* 	Class that contains static utility methods for manipulating and working
+	*	with Arrays.
+	* 
+	*	Note that all APIs assume that they are working with well formed arrays.
+	*	i.e. they will only manipulate indexed values.  
+	* 
+	* 	@langversion ActionScript 3.0
+	*	@playerversion Flash 9.0
+	*	@tiptext
+	*/		
+	public class ArrayUtil
+	{
+				
+		/**
+		*	Determines whether the specified array contains the specified value.	
+		* 
+		* 	@param arr The array that will be checked for the specified value.
+		*
+		*	@param value The object which will be searched for within the array
+		* 
+		* 	@return True if the array contains the value, False if it does not.
+		*
+		* 	@langversion ActionScript 3.0
+		*	@playerversion Flash 9.0
+		*	@tiptext
+		*/			
+		public static function arrayContainsValue(arr:Array, value:Object):Boolean
+		{
+			return (arr.indexOf(value) != -1);
+		}	
+		
+		/**
+		*	Remove all instances of the specified value from the array,
+		* 
+		* 	@param arr The array from which the value will be removed
+		*
+		*	@param value The object that will be removed from the array.
+		*
+		* 	@langversion ActionScript 3.0
+		*	@playerversion Flash 9.0
+		*	@tiptext
+		*/		
+		public static function removeValueFromArray(arr:Array, value:Object):void
+		{
+			var len:uint = arr.length;
+			
+			for(var i:Number = len; i > -1; i--)
+			{
+				if(arr[i] === value)
+				{
+					arr.splice(i, 1);
+				}
+			}					
+		}
+
+		/**
+		*	Create a new array that only contains unique instances of objects
+		*	in the specified array.
+		*
+		*	Basically, this can be used to remove duplication object instances
+		*	from an array
+		* 
+		* 	@param arr The array which contains the values that will be used to
+		*	create the new array that contains no duplicate values.
+		*
+		*	@return A new array which only contains unique items from the specified
+		*	array.
+		*
+		* 	@langversion ActionScript 3.0
+		*	@playerversion Flash 9.0
+		*	@tiptext
+		*/	
+		public static function createUniqueCopy(a:Array):Array
+		{
+			var newArray:Array = new Array();
+			
+			var len:Number = a.length;
+			var item:Object;
+			
+			for (var i:uint = 0; i < len; ++i)
+			{
+				item = a[i];
+				
+				if(ArrayUtil.arrayContainsValue(newArray, item))
+				{
+					continue;
+				}
+				
+				newArray.push(item);
+			}
+			
+			return newArray;
+		}
+		
+		/**
+		*	Creates a copy of the specified array.
+		*
+		*	Note that the array returned is a new array but the items within the
+		*	array are not copies of the items in the original array (but rather 
+		*	references to the same items)
+		* 
+		* 	@param arr The array that will be copies
+		*
+		*	@return A new array which contains the same items as the array passed
+		*	in.
+		*
+		* 	@langversion ActionScript 3.0
+		*	@playerversion Flash 9.0
+		*	@tiptext
+		*/			
+		public static function copyArray(arr:Array):Array
+		{	
+			return arr.slice();
+		}
+		
+		/**
+		*	Compares two arrays and returns a boolean indicating whether the arrays
+		*	contain the same values at the same indexes.
+		* 
+		* 	@param arr1 The first array that will be compared to the second.
+		*
+		* 	@param arr2 The second array that will be compared to the first.
+		*
+		*	@return True if the arrays contains the same values at the same indexes.
+			False if they do not.
+		*
+		* 	@langversion ActionScript 3.0
+		*	@playerversion Flash 9.0
+		*	@tiptext
+		*/		
+		public static function arraysAreEqual(arr1:Array, arr2:Array):Boolean
+		{
+			if(arr1.length != arr2.length)
+			{
+				return false;
+			}
+			
+			var len:Number = arr1.length;
+			
+			for(var i:Number = 0; i < len; i++)
+			{
+				if(arr1[i] !== arr2[i])
+				{
+					return false;
+				}
+			}
+			
+			return true;
+		}
+	}
+}