Upload folder using huggingface_hub

.gitattributes

@@ -44,3 +44,5 @@ assets/night2day_results.jpg filter=lfs diff=lfs merge=lfs -text
 assets/rainy2clear.jpg filter=lfs diff=lfs merge=lfs -text
 assets/teaser_results.jpg filter=lfs diff=lfs merge=lfs -text
 triton-2.1.0-cp310-cp310-win_amd64.whl filter=lfs diff=lfs merge=lfs -text
+DISPLAYER/Displayer.app/Adobe[[:space:]]AIR/Versions/1.0/Adobe[[:space:]]AIR.dll filter=lfs diff=lfs merge=lfs -text
+Displayer.app/Adobe[[:space:]]AIR/Versions/1.0/Adobe[[:space:]]AIR.dll filter=lfs diff=lfs merge=lfs -text

DISPLAYER/Displayer-app.xml

@@ -0,0 +1,38 @@
+<?xml version="1.0" encoding="utf-8" standalone="no" ?>
+<!-- 
+	Usage:
+
+	To localize the description, use the following format for the description element.
+	<description>
+	<text xml:lang="en">English App description goes here</text>
+	<text xml:lang="fr">French App description goes here</text>
+	<text xml:lang="ja">Japanese App description goes here</text>
+	</description>
+
+	To localize the name, use the following format for the name element.
+	<name>
+	<text xml:lang="en">English App name goes here</text>
+	<text xml:lang="fr">French App name goes here</text>
+	<text xml:lang="ja">Japanese App name goes here</text>
+	</name>
+-->
+<application xmlns="http://ns.adobe.com/air/application/50.2">
+  <id>Displayer</id>
+  <versionNumber>1.0</versionNumber>
+  <filename>Displayer</filename>
+  <description/>
+  <name>Displayer</name>
+  <copyright/>
+  <initialWindow>
+    <content>Displayer.swf</content>
+    <systemChrome>standard</systemChrome>
+    <transparent>false</transparent>
+    <visible>true</visible>
+    <fullScreen>false</fullScreen>
+    <aspectRatio>portrait</aspectRatio>
+    <renderMode>auto</renderMode>
+  </initialWindow>
+  <icon/>
+  <customUpdateUI>false</customUpdateUI>
+  <allowBrowserInvocation>false</allowBrowserInvocation>
+</application>

DISPLAYER/Displayer.app/Adobe AIR/Versions/1.0/Adobe AIR.dll

@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:a819617159ddc7aab0c1c495ec3a7baf7ebb8715e382a63745cffdb366429d48
+size 15256032

DISPLAYER/Displayer.app/Adobe AIR/Versions/1.0/Resources/Licenses/cairo/COPYING

@@ -0,0 +1,33 @@
+Cairo is free software.
+
+Every source file in the implementation[*] of cairo is available to be
+redistributed and/or modified under the terms of either the GNU Lesser
+General Public License (LGPL) version 2.1 or the Mozilla Public
+License (MPL) version 1.1.  Some files are available under more
+liberal terms, but we believe that in all cases, each file may be used
+under either the LGPL or the MPL.
+
+See the following files in this directory for the precise terms and
+conditions of either license:
+
+	COPYING-LGPL-2.1
+	COPYING-MPL-1.1
+
+Please see each file in the implementation for copyright and licensing
+information, (in the opening comment of each file).
+
+[*] The implementation of cairo is contained entirely within the "src"
+directory of the cairo source distribution. There are other components
+of the cairo source distribution (such as the "test", "util", and "perf")
+that are auxiliary to the library itself. None of the source code in these
+directories contributes to a build of the cairo library itself, (libcairo.so
+or cairo.dll or similar).
+
+These auxiliary components are also free software, but may be under
+different license terms than cairo itself. For example, most of the
+test cases in the perf and test directories are made available under
+an MIT license to simplify any use of this code for reference purposes
+in using cairo itself. Other files might be available under the GNU
+General Public License (GPL), for example. Again, please see the COPYING
+file under each directory and the opening comment of each file for copyright
+and licensing information.

DISPLAYER/Displayer.app/Adobe AIR/Versions/1.0/Resources/Licenses/cairo/COPYING-LGPL-2.1

@@ -0,0 +1,510 @@
+
+                  GNU LESSER GENERAL PUBLIC LICENSE
+                       Version 2.1, February 1999
+
+ Copyright (C) 1991, 1999 Free Software Foundation, Inc.
+     51 Franklin Street, Suite 500, Boston, MA 02110-1335, USA
+ Everyone is permitted to copy and distribute verbatim copies
+ of this license document, but changing it is not allowed.
+
+[This is the first released version of the Lesser GPL.  It also counts
+ as the successor of the GNU Library Public License, version 2, hence
+ the version number 2.1.]
+
+                            Preamble
+
+  The licenses for most software are designed to take away your
+freedom to share and change it.  By contrast, the GNU General Public
+Licenses are intended to guarantee your freedom to share and change
+free software--to make sure the software is free for all its users.
+
+  This license, the Lesser General Public License, applies to some
+specially designated software packages--typically libraries--of the
+Free Software Foundation and other authors who decide to use it.  You
+can use it too, but we suggest you first think carefully about whether
+this license or the ordinary General Public License is the better
+strategy to use in any particular case, based on the explanations
+below.
+
+  When we speak of free software, we are referring to freedom of use,
+not price.  Our General Public Licenses are designed to make sure that
+you have the freedom to distribute copies of free software (and charge
+for this service if you wish); that you receive source code or can get
+it if you want it; that you can change the software and use pieces of
+it in new free programs; and that you are informed that you can do
+these things.
+
+  To protect your rights, we need to make restrictions that forbid
+distributors to deny you these rights or to ask you to surrender these
+rights.  These restrictions translate to certain responsibilities for
+you if you distribute copies of the library or if you modify it.
+
+  For example, if you distribute copies of the library, whether gratis
+or for a fee, you must give the recipients all the rights that we gave
+you.  You must make sure that they, too, receive or can get the source
+code.  If you link other code with the library, you must provide
+complete object files to the recipients, so that they can relink them
+with the library after making changes to the library and recompiling
+it.  And you must show them these terms so they know their rights.
+
+  We protect your rights with a two-step method: (1) we copyright the
+library, and (2) we offer you this license, which gives you legal
+permission to copy, distribute and/or modify the library.
+
+  To protect each distributor, we want to make it very clear that
+there is no warranty for the free library.  Also, if the library is
+modified by someone else and passed on, the recipients should know
+that what they have is not the original version, so that the original
+author's reputation will not be affected by problems that might be
+introduced by others.
+
+  Finally, software patents pose a constant threat to the existence of
+any free program.  We wish to make sure that a company cannot
+effectively restrict the users of a free program by obtaining a
+restrictive license from a patent holder.  Therefore, we insist that
+any patent license obtained for a version of the library must be
+consistent with the full freedom of use specified in this license.
+
+  Most GNU software, including some libraries, is covered by the
+ordinary GNU General Public License.  This license, the GNU Lesser
+General Public License, applies to certain designated libraries, and
+is quite different from the ordinary General Public License.  We use
+this license for certain libraries in order to permit linking those
+libraries into non-free programs.
+
+  When a program is linked with a library, whether statically or using
+a shared library, the combination of the two is legally speaking a
+combined work, a derivative of the original library.  The ordinary
+General Public License therefore permits such linking only if the
+entire combination fits its criteria of freedom.  The Lesser General
+Public License permits more lax criteria for linking other code with
+the library.
+
+  We call this license the "Lesser" General Public License because it
+does Less to protect the user's freedom than the ordinary General
+Public License.  It also provides other free software developers Less
+of an advantage over competing non-free programs.  These disadvantages
+are the reason we use the ordinary General Public License for many
+libraries.  However, the Lesser license provides advantages in certain
+special circumstances.
+
+  For example, on rare occasions, there may be a special need to
+encourage the widest possible use of a certain library, so that it
+becomes a de-facto standard.  To achieve this, non-free programs must
+be allowed to use the library.  A more frequent case is that a free
+library does the same job as widely used non-free libraries.  In this
+case, there is little to gain by limiting the free library to free
+software only, so we use the Lesser General Public License.
+
+  In other cases, permission to use a particular library in non-free
+programs enables a greater number of people to use a large body of
+free software.  For example, permission to use the GNU C Library in
+non-free programs enables many more people to use the whole GNU
+operating system, as well as its variant, the GNU/Linux operating
+system.
+
+  Although the Lesser General Public License is Less protective of the
+users' freedom, it does ensure that the user of a program that is
+linked with the Library has the freedom and the wherewithal to run
+that program using a modified version of the Library.
+
+  The precise terms and conditions for copying, distribution and
+modification follow.  Pay close attention to the difference between a
+"work based on the library" and a "work that uses the library".  The
+former contains code derived from the library, whereas the latter must
+be combined with the library in order to run.
+
+                  GNU LESSER GENERAL PUBLIC LICENSE
+   TERMS AND CONDITIONS FOR COPYING, DISTRIBUTION AND MODIFICATION
+
+  0. This License Agreement applies to any software library or other
+program which contains a notice placed by the copyright holder or
+other authorized party saying it may be distributed under the terms of
+this Lesser General Public License (also called "this License").
+Each licensee is addressed as "you".
+
+  A "library" means a collection of software functions and/or data
+prepared so as to be conveniently linked with application programs
+(which use some of those functions and data) to form executables.
+
+  The "Library", below, refers to any such software library or work
+which has been distributed under these terms.  A "work based on the
+Library" means either the Library or any derivative work under
+copyright law: that is to say, a work containing the Library or a
+portion of it, either verbatim or with modifications and/or translated
+straightforwardly into another language.  (Hereinafter, translation is
+included without limitation in the term "modification".)
+
+  "Source code" for a work means the preferred form of the work for
+making modifications to it.  For a library, complete source code means
+all the source code for all modules it contains, plus any associated
+interface definition files, plus the scripts used to control
+compilation and installation of the library.
+
+  Activities other than copying, distribution and modification are not
+covered by this License; they are outside its scope.  The act of
+running a program using the Library is not restricted, and output from
+such a program is covered only if its contents constitute a work based
+on the Library (independent of the use of the Library in a tool for
+writing it).  Whether that is true depends on what the Library does
+and what the program that uses the Library does.
+
+  1. You may copy and distribute verbatim copies of the Library's
+complete source code as you receive it, in any medium, provided that
+you conspicuously and appropriately publish on each copy an
+appropriate copyright notice and disclaimer of warranty; keep intact
+all the notices that refer to this License and to the absence of any
+warranty; and distribute a copy of this License along with the
+Library.
+
+  You may charge a fee for the physical act of transferring a copy,
+and you may at your option offer warranty protection in exchange for a
+fee.
+
+  2. You may modify your copy or copies of the Library or any portion
+of it, thus forming a work based on the Library, and copy and
+distribute such modifications or work under the terms of Section 1
+above, provided that you also meet all of these conditions:
+
+    a) The modified work must itself be a software library.
+
+    b) You must cause the files modified to carry prominent notices
+    stating that you changed the files and the date of any change.
+
+    c) You must cause the whole of the work to be licensed at no
+    charge to all third parties under the terms of this License.
+
+    d) If a facility in the modified Library refers to a function or a
+    table of data to be supplied by an application program that uses
+    the facility, other than as an argument passed when the facility
+    is invoked, then you must make a good faith effort to ensure that,
+    in the event an application does not supply such function or
+    table, the facility still operates, and performs whatever part of
+    its purpose remains meaningful.
+
+    (For example, a function in a library to compute square roots has
+    a purpose that is entirely well-defined independent of the
+    application.  Therefore, Subsection 2d requires that any
+    application-supplied function or table used by this function must
+    be optional: if the application does not supply it, the square
+    root function must still compute square roots.)
+
+These requirements apply to the modified work as a whole.  If
+identifiable sections of that work are not derived from the Library,
+and can be reasonably considered independent and separate works in
+themselves, then this License, and its terms, do not apply to those
+sections when you distribute them as separate works.  But when you
+distribute the same sections as part of a whole which is a work based
+on the Library, the distribution of the whole must be on the terms of
+this License, whose permissions for other licensees extend to the
+entire whole, and thus to each and every part regardless of who wrote
+it.
+
+Thus, it is not the intent of this section to claim rights or contest
+your rights to work written entirely by you; rather, the intent is to
+exercise the right to control the distribution of derivative or
+collective works based on the Library.
+
+In addition, mere aggregation of another work not based on the Library
+with the Library (or with a work based on the Library) on a volume of
+a storage or distribution medium does not bring the other work under
+the scope of this License.
+
+  3. You may opt to apply the terms of the ordinary GNU General Public
+License instead of this License to a given copy of the Library.  To do
+this, you must alter all the notices that refer to this License, so
+that they refer to the ordinary GNU General Public License, version 2,
+instead of to this License.  (If a newer version than version 2 of the
+ordinary GNU General Public License has appeared, then you can specify
+that version instead if you wish.)  Do not make any other change in
+these notices.
+
+  Once this change is made in a given copy, it is irreversible for
+that copy, so the ordinary GNU General Public License applies to all
+subsequent copies and derivative works made from that copy.
+
+  This option is useful when you wish to copy part of the code of
+the Library into a program that is not a library.
+
+  4. You may copy and distribute the Library (or a portion or
+derivative of it, under Section 2) in object code or executable form
+under the terms of Sections 1 and 2 above provided that you accompany
+it with the complete corresponding machine-readable source code, which
+must be distributed under the terms of Sections 1 and 2 above on a
+medium customarily used for software interchange.
+
+  If distribution of object code is made by offering access to copy
+from a designated place, then offering equivalent access to copy the
+source code from the same place satisfies the requirement to
+distribute the source code, even though third parties are not
+compelled to copy the source along with the object code.
+
+  5. A program that contains no derivative of any portion of the
+Library, but is designed to work with the Library by being compiled or
+linked with it, is called a "work that uses the Library".  Such a
+work, in isolation, is not a derivative work of the Library, and
+therefore falls outside the scope of this License.
+
+  However, linking a "work that uses the Library" with the Library
+creates an executable that is a derivative of the Library (because it
+contains portions of the Library), rather than a "work that uses the
+library".  The executable is therefore covered by this License.
+Section 6 states terms for distribution of such executables.
+
+  When a "work that uses the Library" uses material from a header file
+that is part of the Library, the object code for the work may be a
+derivative work of the Library even though the source code is not.
+Whether this is true is especially significant if the work can be
+linked without the Library, or if the work is itself a library.  The
+threshold for this to be true is not precisely defined by law.
+
+  If such an object file uses only numerical parameters, data
+structure layouts and accessors, and small macros and small inline
+functions (ten lines or less in length), then the use of the object
+file is unrestricted, regardless of whether it is legally a derivative
+work.  (Executables containing this object code plus portions of the
+Library will still fall under Section 6.)
+
+  Otherwise, if the work is a derivative of the Library, you may
+distribute the object code for the work under the terms of Section 6.
+Any executables containing that work also fall under Section 6,
+whether or not they are linked directly with the Library itself.
+
+  6. As an exception to the Sections above, you may also combine or
+link a "work that uses the Library" with the Library to produce a
+work containing portions of the Library, and distribute that work
+under terms of your choice, provided that the terms permit
+modification of the work for the customer's own use and reverse
+engineering for debugging such modifications.
+
+  You must give prominent notice with each copy of the work that the
+Library is used in it and that the Library and its use are covered by
+this License.  You must supply a copy of this License.  If the work
+during execution displays copyright notices, you must include the
+copyright notice for the Library among them, as well as a reference
+directing the user to the copy of this License.  Also, you must do one
+of these things:
+
+    a) Accompany the work with the complete corresponding
+    machine-readable source code for the Library including whatever
+    changes were used in the work (which must be distributed under
+    Sections 1 and 2 above); and, if the work is an executable linked
+    with the Library, with the complete machine-readable "work that
+    uses the Library", as object code and/or source code, so that the
+    user can modify the Library and then relink to produce a modified
+    executable containing the modified Library.  (It is understood
+    that the user who changes the contents of definitions files in the
+    Library will not necessarily be able to recompile the application
+    to use the modified definitions.)
+
+    b) Use a suitable shared library mechanism for linking with the
+    Library.  A suitable mechanism is one that (1) uses at run time a
+    copy of the library already present on the user's computer system,
+    rather than copying library functions into the executable, and (2)
+    will operate properly with a modified version of the library, if
+    the user installs one, as long as the modified version is
+    interface-compatible with the version that the work was made with.
+
+    c) Accompany the work with a written offer, valid for at least
+    three years, to give the same user the materials specified in
+    Subsection 6a, above, for a charge no more than the cost of
+    performing this distribution.
+
+    d) If distribution of the work is made by offering access to copy
+    from a designated place, offer equivalent access to copy the above
+    specified materials from the same place.
+
+    e) Verify that the user has already received a copy of these
+    materials or that you have already sent this user a copy.
+
+  For an executable, the required form of the "work that uses the
+Library" must include any data and utility programs needed for
+reproducing the executable from it.  However, as a special exception,
+the materials to be distributed need not include anything that is
+normally distributed (in either source or binary form) with the major
+components (compiler, kernel, and so on) of the operating system on
+which the executable runs, unless that component itself accompanies
+the executable.
+
+  It may happen that this requirement contradicts the license
+restrictions of other proprietary libraries that do not normally
+accompany the operating system.  Such a contradiction means you cannot
+use both them and the Library together in an executable that you
+distribute.
+
+  7. You may place library facilities that are a work based on the
+Library side-by-side in a single library together with other library
+facilities not covered by this License, and distribute such a combined
+library, provided that the separate distribution of the work based on
+the Library and of the other library facilities is otherwise
+permitted, and provided that you do these two things:
+
+    a) Accompany the combined library with a copy of the same work
+    based on the Library, uncombined with any other library
+    facilities.  This must be distributed under the terms of the
+    Sections above.
+
+    b) Give prominent notice with the combined library of the fact
+    that part of it is a work based on the Library, and explaining
+    where to find the accompanying uncombined form of the same work.
+
+  8. You may not copy, modify, sublicense, link with, or distribute
+the Library except as expressly provided under this License.  Any
+attempt otherwise to copy, modify, sublicense, link with, or
+distribute the Library is void, and will automatically terminate your
+rights under this License.  However, parties who have received copies,
+or rights, from you under this License will not have their licenses
+terminated so long as such parties remain in full compliance.
+
+  9. You are not required to accept this License, since you have not
+signed it.  However, nothing else grants you permission to modify or
+distribute the Library or its derivative works.  These actions are
+prohibited by law if you do not accept this License.  Therefore, by
+modifying or distributing the Library (or any work based on the
+Library), you indicate your acceptance of this License to do so, and
+all its terms and conditions for copying, distributing or modifying
+the Library or works based on it.
+
+  10. Each time you redistribute the Library (or any work based on the
+Library), the recipient automatically receives a license from the
+original licensor to copy, distribute, link with or modify the Library
+subject to these terms and conditions.  You may not impose any further
+restrictions on the recipients' exercise of the rights granted herein.
+You are not responsible for enforcing compliance by third parties with
+this License.
+
+  11. If, as a consequence of a court judgment or allegation of patent
+infringement or for any other reason (not limited to patent issues),
+conditions are imposed on you (whether by court order, agreement or
+otherwise) that contradict the conditions of this License, they do not
+excuse you from the conditions of this License.  If you cannot
+distribute so as to satisfy simultaneously your obligations under this
+License and any other pertinent obligations, then as a consequence you
+may not distribute the Library at all.  For example, if a patent
+license would not permit royalty-free redistribution of the Library by
+all those who receive copies directly or indirectly through you, then
+the only way you could satisfy both it and this License would be to
+refrain entirely from distribution of the Library.
+
+If any portion of this section is held invalid or unenforceable under
+any particular circumstance, the balance of the section is intended to
+apply, and the section as a whole is intended to apply in other
+circumstances.
+
+It is not the purpose of this section to induce you to infringe any
+patents or other property right claims or to contest validity of any
+such claims; this section has the sole purpose of protecting the
+integrity of the free software distribution system which is
+implemented by public license practices.  Many people have made
+generous contributions to the wide range of software distributed
+through that system in reliance on consistent application of that
+system; it is up to the author/donor to decide if he or she is willing
+to distribute software through any other system and a licensee cannot
+impose that choice.
+
+This section is intended to make thoroughly clear what is believed to
+be a consequence of the rest of this License.
+
+  12. If the distribution and/or use of the Library is restricted in
+certain countries either by patents or by copyrighted interfaces, the
+original copyright holder who places the Library under this License
+may add an explicit geographical distribution limitation excluding those
+countries, so that distribution is permitted only in or among
+countries not thus excluded.  In such case, this License incorporates
+the limitation as if written in the body of this License.
+
+  13. The Free Software Foundation may publish revised and/or new
+versions of the Lesser General Public License from time to time.
+Such new versions will be similar in spirit to the present version,
+but may differ in detail to address new problems or concerns.
+
+Each version is given a distinguishing version number.  If the Library
+specifies a version number of this License which applies to it and
+"any later version", you have the option of following the terms and
+conditions either of that version or of any later version published by
+the Free Software Foundation.  If the Library does not specify a
+license version number, you may choose any version ever published by
+the Free Software Foundation.
+
+  14. If you wish to incorporate parts of the Library into other free
+programs whose distribution conditions are incompatible with these,
+write to the author to ask for permission.  For software which is
+copyrighted by the Free Software Foundation, write to the Free
+Software Foundation; we sometimes make exceptions for this.  Our
+decision will be guided by the two goals of preserving the free status
+of all derivatives of our free software and of promoting the sharing
+and reuse of software generally.
+
+                            NO WARRANTY
+
+  15. BECAUSE THE LIBRARY IS LICENSED FREE OF CHARGE, THERE IS NO
+WARRANTY FOR THE LIBRARY, TO THE EXTENT PERMITTED BY APPLICABLE LAW.
+EXCEPT WHEN OTHERWISE STATED IN WRITING THE COPYRIGHT HOLDERS AND/OR
+OTHER PARTIES PROVIDE THE LIBRARY "AS IS" WITHOUT WARRANTY OF ANY
+KIND, EITHER EXPRESSED OR IMPLIED, INCLUDING, BUT NOT LIMITED TO, THE
+IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR
+PURPOSE.  THE ENTIRE RISK AS TO THE QUALITY AND PERFORMANCE OF THE
+LIBRARY IS WITH YOU.  SHOULD THE LIBRARY PROVE DEFECTIVE, YOU ASSUME
+THE COST OF ALL NECESSARY SERVICING, REPAIR OR CORRECTION.
+
+  16. IN NO EVENT UNLESS REQUIRED BY APPLICABLE LAW OR AGREED TO IN
+WRITING WILL ANY COPYRIGHT HOLDER, OR ANY OTHER PARTY WHO MAY MODIFY
+AND/OR REDISTRIBUTE THE LIBRARY AS PERMITTED ABOVE, BE LIABLE TO YOU
+FOR DAMAGES, INCLUDING ANY GENERAL, SPECIAL, INCIDENTAL OR
+CONSEQUENTIAL DAMAGES ARISING OUT OF THE USE OR INABILITY TO USE THE
+LIBRARY (INCLUDING BUT NOT LIMITED TO LOSS OF DATA OR DATA BEING
+RENDERED INACCURATE OR LOSSES SUSTAINED BY YOU OR THIRD PARTIES OR A
+FAILURE OF THE LIBRARY TO OPERATE WITH ANY OTHER SOFTWARE), EVEN IF
+SUCH HOLDER OR OTHER PARTY HAS BEEN ADVISED OF THE POSSIBILITY OF SUCH
+DAMAGES.
+
+                     END OF TERMS AND CONDITIONS
+
+           How to Apply These Terms to Your New Libraries
+
+  If you develop a new library, and you want it to be of the greatest
+possible use to the public, we recommend making it free software that
+everyone can redistribute and change.  You can do so by permitting
+redistribution under these terms (or, alternatively, under the terms
+of the ordinary General Public License).
+
+  To apply these terms, attach the following notices to the library.
+It is safest to attach them to the start of each source file to most
+effectively convey the exclusion of warranty; and each file should
+have at least the "copyright" line and a pointer to where the full
+notice is found.
+
+
+    <one line to give the library's name and a brief idea of what it does.>
+    Copyright (C) <year>  <name of author>
+
+    This library is free software; you can redistribute it and/or
+    modify it under the terms of the GNU Lesser General Public
+    License as published by the Free Software Foundation; either
+    version 2.1 of the License, or (at your option) any later version.
+
+    This library is distributed in the hope that it will be useful,
+    but WITHOUT ANY WARRANTY; without even the implied warranty of
+    MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
+    Lesser General Public License for more details.
+
+    You should have received a copy of the GNU Lesser General Public
+    License along with this library; if not, write to the Free Software
+    Foundation, Inc., 51 Franklin Street, Suite 500, Boston, MA 02110-1335, USA
+
+Also add information on how to contact you by electronic and paper mail.
+
+You should also get your employer (if you work as a programmer) or
+your school, if any, to sign a "copyright disclaimer" for the library,
+if necessary.  Here is a sample; alter the names:
+
+  Yoyodyne, Inc., hereby disclaims all copyright interest in the
+  library `Frob' (a library for tweaking knobs) written by James
+  Random Hacker.
+
+  <signature of Ty Coon>, 1 April 1990
+  Ty Coon, President of Vice
+
+That's all there is to it!
+
+

DISPLAYER/Displayer.app/Adobe AIR/Versions/1.0/Resources/Licenses/cairo/COPYING-MPL-1.1

@@ -0,0 +1,470 @@
+                          MOZILLA PUBLIC LICENSE
+                                Version 1.1
+
+                              ---------------
+
+1. Definitions.
+
+     1.0.1. "Commercial Use" means distribution or otherwise making the
+     Covered Code available to a third party.
+
+     1.1. "Contributor" means each entity that creates or contributes to
+     the creation of Modifications.
+
+     1.2. "Contributor Version" means the combination of the Original
+     Code, prior Modifications used by a Contributor, and the Modifications
+     made by that particular Contributor.
+
+     1.3. "Covered Code" means the Original Code or Modifications or the
+     combination of the Original Code and Modifications, in each case
+     including portions thereof.
+
+     1.4. "Electronic Distribution Mechanism" means a mechanism generally
+     accepted in the software development community for the electronic
+     transfer of data.
+
+     1.5. "Executable" means Covered Code in any form other than Source
+     Code.
+
+     1.6. "Initial Developer" means the individual or entity identified
+     as the Initial Developer in the Source Code notice required by Exhibit
+     A.
+
+     1.7. "Larger Work" means a work which combines Covered Code or
+     portions thereof with code not governed by the terms of this License.
+
+     1.8. "License" means this document.
+
+     1.8.1. "Licensable" means having the right to grant, to the maximum
+     extent possible, whether at the time of the initial grant or
+     subsequently acquired, any and all of the rights conveyed herein.
+
+     1.9. "Modifications" means any addition to or deletion from the
+     substance or structure of either the Original Code or any previous
+     Modifications. When Covered Code is released as a series of files, a
+     Modification is:
+          A. Any addition to or deletion from the contents of a file
+          containing Original Code or previous Modifications.
+
+          B. Any new file that contains any part of the Original Code or
+          previous Modifications.
+
+     1.10. "Original Code" means Source Code of computer software code
+     which is described in the Source Code notice required by Exhibit A as
+     Original Code, and which, at the time of its release under this
+     License is not already Covered Code governed by this License.
+
+     1.10.1. "Patent Claims" means any patent claim(s), now owned or
+     hereafter acquired, including without limitation,  method, process,
+     and apparatus claims, in any patent Licensable by grantor.
+
+     1.11. "Source Code" means the preferred form of the Covered Code for
+     making modifications to it, including all modules it contains, plus
+     any associated interface definition files, scripts used to control
+     compilation and installation of an Executable, or source code
+     differential comparisons against either the Original Code or another
+     well known, available Covered Code of the Contributor's choice. The
+     Source Code can be in a compressed or archival form, provided the
+     appropriate decompression or de-archiving software is widely available
+     for no charge.
+
+     1.12. "You" (or "Your")  means an individual or a legal entity
+     exercising rights under, and complying with all of the terms of, this
+     License or a future version of this License issued under Section 6.1.
+     For legal entities, "You" includes any entity which controls, is
+     controlled by, or is under common control with You. For purposes of
+     this definition, "control" means (a) the power, direct or indirect,
+     to cause the direction or management of such entity, whether by
+     contract or otherwise, or (b) ownership of more than fifty percent
+     (50%) of the outstanding shares or beneficial ownership of such
+     entity.
+
+2. Source Code License.
+
+     2.1. The Initial Developer Grant.
+     The Initial Developer hereby grants You a world-wide, royalty-free,
+     non-exclusive license, subject to third party intellectual property
+     claims:
+          (a)  under intellectual property rights (other than patent or
+          trademark) Licensable by Initial Developer to use, reproduce,
+          modify, display, perform, sublicense and distribute the Original
+          Code (or portions thereof) with or without Modifications, and/or
+          as part of a Larger Work; and
+
+          (b) under Patents Claims infringed by the making, using or
+          selling of Original Code, to make, have made, use, practice,
+          sell, and offer for sale, and/or otherwise dispose of the
+          Original Code (or portions thereof).
+
+          (c) the licenses granted in this Section 2.1(a) and (b) are
+          effective on the date Initial Developer first distributes
+          Original Code under the terms of this License.
+
+          (d) Notwithstanding Section 2.1(b) above, no patent license is
+          granted: 1) for code that You delete from the Original Code; 2)
+          separate from the Original Code;  or 3) for infringements caused
+          by: i) the modification of the Original Code or ii) the
+          combination of the Original Code with other software or devices.
+
+     2.2. Contributor Grant.
+     Subject to third party intellectual property claims, each Contributor
+     hereby grants You a world-wide, royalty-free, non-exclusive license
+
+          (a)  under intellectual property rights (other than patent or
+          trademark) Licensable by Contributor, to use, reproduce, modify,
+          display, perform, sublicense and distribute the Modifications
+          created by such Contributor (or portions thereof) either on an
+          unmodified basis, with other Modifications, as Covered Code
+          and/or as part of a Larger Work; and
+
+          (b) under Patent Claims infringed by the making, using, or
+          selling of  Modifications made by that Contributor either alone
+          and/or in combination with its Contributor Version (or portions
+          of such combination), to make, use, sell, offer for sale, have
+          made, and/or otherwise dispose of: 1) Modifications made by that
+          Contributor (or portions thereof); and 2) the combination of
+          Modifications made by that Contributor with its Contributor
+          Version (or portions of such combination).
+
+          (c) the licenses granted in Sections 2.2(a) and 2.2(b) are
+          effective on the date Contributor first makes Commercial Use of
+          the Covered Code.
+
+          (d)    Notwithstanding Section 2.2(b) above, no patent license is
+          granted: 1) for any code that Contributor has deleted from the
+          Contributor Version; 2)  separate from the Contributor Version;
+          3)  for infringements caused by: i) third party modifications of
+          Contributor Version or ii)  the combination of Modifications made
+          by that Contributor with other software  (except as part of the
+          Contributor Version) or other devices; or 4) under Patent Claims
+          infringed by Covered Code in the absence of Modifications made by
+          that Contributor.
+
+3. Distribution Obligations.
+
+     3.1. Application of License.
+     The Modifications which You create or to which You contribute are
+     governed by the terms of this License, including without limitation
+     Section 2.2. The Source Code version of Covered Code may be
+     distributed only under the terms of this License or a future version
+     of this License released under Section 6.1, and You must include a
+     copy of this License with every copy of the Source Code You
+     distribute. You may not offer or impose any terms on any Source Code
+     version that alters or restricts the applicable version of this
+     License or the recipients' rights hereunder. However, You may include
+     an additional document offering the additional rights described in
+     Section 3.5.
+
+     3.2. Availability of Source Code.
+     Any Modification which You create or to which You contribute must be
+     made available in Source Code form under the terms of this License
+     either on the same media as an Executable version or via an accepted
+     Electronic Distribution Mechanism to anyone to whom you made an
+     Executable version available; and if made available via Electronic
+     Distribution Mechanism, must remain available for at least twelve (12)
+     months after the date it initially became available, or at least six
+     (6) months after a subsequent version of that particular Modification
+     has been made available to such recipients. You are responsible for
+     ensuring that the Source Code version remains available even if the
+     Electronic Distribution Mechanism is maintained by a third party.
+
+     3.3. Description of Modifications.
+     You must cause all Covered Code to which You contribute to contain a
+     file documenting the changes You made to create that Covered Code and
+     the date of any change. You must include a prominent statement that
+     the Modification is derived, directly or indirectly, from Original
+     Code provided by the Initial Developer and including the name of the
+     Initial Developer in (a) the Source Code, and (b) in any notice in an
+     Executable version or related documentation in which You describe the
+     origin or ownership of the Covered Code.
+
+     3.4. Intellectual Property Matters
+          (a) Third Party Claims.
+          If Contributor has knowledge that a license under a third party's
+          intellectual property rights is required to exercise the rights
+          granted by such Contributor under Sections 2.1 or 2.2,
+          Contributor must include a text file with the Source Code
+          distribution titled "LEGAL" which describes the claim and the
+          party making the claim in sufficient detail that a recipient will
+          know whom to contact. If Contributor obtains such knowledge after
+          the Modification is made available as described in Section 3.2,
+          Contributor shall promptly modify the LEGAL file in all copies
+          Contributor makes available thereafter and shall take other steps
+          (such as notifying appropriate mailing lists or newsgroups)
+          reasonably calculated to inform those who received the Covered
+          Code that new knowledge has been obtained.
+
+          (b) Contributor APIs.
+          If Contributor's Modifications include an application programming
+          interface and Contributor has knowledge of patent licenses which
+          are reasonably necessary to implement that API, Contributor must
+          also include this information in the LEGAL file.
+
+               (c)    Representations.
+          Contributor represents that, except as disclosed pursuant to
+          Section 3.4(a) above, Contributor believes that Contributor's
+          Modifications are Contributor's original creation(s) and/or
+          Contributor has sufficient rights to grant the rights conveyed by
+          this License.
+
+     3.5. Required Notices.
+     You must duplicate the notice in Exhibit A in each file of the Source
+     Code.  If it is not possible to put such notice in a particular Source
+     Code file due to its structure, then You must include such notice in a
+     location (such as a relevant directory) where a user would be likely
+     to look for such a notice.  If You created one or more Modification(s)
+     You may add your name as a Contributor to the notice described in
+     Exhibit A.  You must also duplicate this License in any documentation
+     for the Source Code where You describe recipients' rights or ownership
+     rights relating to Covered Code.  You may choose to offer, and to
+     charge a fee for, warranty, support, indemnity or liability
+     obligations to one or more recipients of Covered Code. However, You
+     may do so only on Your own behalf, and not on behalf of the Initial
+     Developer or any Contributor. You must make it absolutely clear than
+     any such warranty, support, indemnity or liability obligation is
+     offered by You alone, and You hereby agree to indemnify the Initial
+     Developer and every Contributor for any liability incurred by the
+     Initial Developer or such Contributor as a result of warranty,
+     support, indemnity or liability terms You offer.
+
+     3.6. Distribution of Executable Versions.
+     You may distribute Covered Code in Executable form only if the
+     requirements of Section 3.1-3.5 have been met for that Covered Code,
+     and if You include a notice stating that the Source Code version of
+     the Covered Code is available under the terms of this License,
+     including a description of how and where You have fulfilled the
+     obligations of Section 3.2. The notice must be conspicuously included
+     in any notice in an Executable version, related documentation or
+     collateral in which You describe recipients' rights relating to the
+     Covered Code. You may distribute the Executable version of Covered
+     Code or ownership rights under a license of Your choice, which may
+     contain terms different from this License, provided that You are in
+     compliance with the terms of this License and that the license for the
+     Executable version does not attempt to limit or alter the recipient's
+     rights in the Source Code version from the rights set forth in this
+     License. If You distribute the Executable version under a different
+     license You must make it absolutely clear that any terms which differ
+     from this License are offered by You alone, not by the Initial
+     Developer or any Contributor. You hereby agree to indemnify the
+     Initial Developer and every Contributor for any liability incurred by
+     the Initial Developer or such Contributor as a result of any such
+     terms You offer.
+
+     3.7. Larger Works.
+     You may create a Larger Work by combining Covered Code with other code
+     not governed by the terms of this License and distribute the Larger
+     Work as a single product. In such a case, You must make sure the
+     requirements of this License are fulfilled for the Covered Code.
+
+4. Inability to Comply Due to Statute or Regulation.
+
+     If it is impossible for You to comply with any of the terms of this
+     License with respect to some or all of the Covered Code due to
+     statute, judicial order, or regulation then You must: (a) comply with
+     the terms of this License to the maximum extent possible; and (b)
+     describe the limitations and the code they affect. Such description
+     must be included in the LEGAL file described in Section 3.4 and must
+     be included with all distributions of the Source Code. Except to the
+     extent prohibited by statute or regulation, such description must be
+     sufficiently detailed for a recipient of ordinary skill to be able to
+     understand it.
+
+5. Application of this License.
+
+     This License applies to code to which the Initial Developer has
+     attached the notice in Exhibit A and to related Covered Code.
+
+6. Versions of the License.
+
+     6.1. New Versions.
+     Netscape Communications Corporation ("Netscape") may publish revised
+     and/or new versions of the License from time to time. Each version
+     will be given a distinguishing version number.
+
+     6.2. Effect of New Versions.
+     Once Covered Code has been published under a particular version of the
+     License, You may always continue to use it under the terms of that
+     version. You may also choose to use such Covered Code under the terms
+     of any subsequent version of the License published by Netscape. No one
+     other than Netscape has the right to modify the terms applicable to
+     Covered Code created under this License.
+
+     6.3. Derivative Works.
+     If You create or use a modified version of this License (which you may
+     only do in order to apply it to code which is not already Covered Code
+     governed by this License), You must (a) rename Your license so that
+     the phrases "Mozilla", "MOZILLAPL", "MOZPL", "Netscape",
+     "MPL", "NPL" or any confusingly similar phrase do not appear in your
+     license (except to note that your license differs from this License)
+     and (b) otherwise make it clear that Your version of the license
+     contains terms which differ from the Mozilla Public License and
+     Netscape Public License. (Filling in the name of the Initial
+     Developer, Original Code or Contributor in the notice described in
+     Exhibit A shall not of themselves be deemed to be modifications of
+     this License.)
+
+7. DISCLAIMER OF WARRANTY.
+
+     COVERED CODE IS PROVIDED UNDER THIS LICENSE ON AN "AS IS" BASIS,
+     WITHOUT WARRANTY OF ANY KIND, EITHER EXPRESSED OR IMPLIED, INCLUDING,
+     WITHOUT LIMITATION, WARRANTIES THAT THE COVERED CODE IS FREE OF
+     DEFECTS, MERCHANTABLE, FIT FOR A PARTICULAR PURPOSE OR NON-INFRINGING.
+     THE ENTIRE RISK AS TO THE QUALITY AND PERFORMANCE OF THE COVERED CODE
+     IS WITH YOU. SHOULD ANY COVERED CODE PROVE DEFECTIVE IN ANY RESPECT,
+     YOU (NOT THE INITIAL DEVELOPER OR ANY OTHER CONTRIBUTOR) ASSUME THE
+     COST OF ANY NECESSARY SERVICING, REPAIR OR CORRECTION. THIS DISCLAIMER
+     OF WARRANTY CONSTITUTES AN ESSENTIAL PART OF THIS LICENSE. NO USE OF
+     ANY COVERED CODE IS AUTHORIZED HEREUNDER EXCEPT UNDER THIS DISCLAIMER.
+
+8. TERMINATION.
+
+     8.1.  This License and the rights granted hereunder will terminate
+     automatically if You fail to comply with terms herein and fail to cure
+     such breach within 30 days of becoming aware of the breach. All
+     sublicenses to the Covered Code which are properly granted shall
+     survive any termination of this License. Provisions which, by their
+     nature, must remain in effect beyond the termination of this License
+     shall survive.
+
+     8.2.  If You initiate litigation by asserting a patent infringement
+     claim (excluding declatory judgment actions) against Initial Developer
+     or a Contributor (the Initial Developer or Contributor against whom
+     You file such action is referred to as "Participant")  alleging that:
+
+     (a)  such Participant's Contributor Version directly or indirectly
+     infringes any patent, then any and all rights granted by such
+     Participant to You under Sections 2.1 and/or 2.2 of this License
+     shall, upon 60 days notice from Participant terminate prospectively,
+     unless if within 60 days after receipt of notice You either: (i)
+     agree in writing to pay Participant a mutually agreeable reasonable
+     royalty for Your past and future use of Modifications made by such
+     Participant, or (ii) withdraw Your litigation claim with respect to
+     the Contributor Version against such Participant.  If within 60 days
+     of notice, a reasonable royalty and payment arrangement are not
+     mutually agreed upon in writing by the parties or the litigation claim
+     is not withdrawn, the rights granted by Participant to You under
+     Sections 2.1 and/or 2.2 automatically terminate at the expiration of
+     the 60 day notice period specified above.
+
+     (b)  any software, hardware, or device, other than such Participant's
+     Contributor Version, directly or indirectly infringes any patent, then
+     any rights granted to You by such Participant under Sections 2.1(b)
+     and 2.2(b) are revoked effective as of the date You first made, used,
+     sold, distributed, or had made, Modifications made by that
+     Participant.
+
+     8.3.  If You assert a patent infringement claim against Participant
+     alleging that such Participant's Contributor Version directly or
+     indirectly infringes any patent where such claim is resolved (such as
+     by license or settlement) prior to the initiation of patent
+     infringement litigation, then the reasonable value of the licenses
+     granted by such Participant under Sections 2.1 or 2.2 shall be taken
+     into account in determining the amount or value of any payment or
+     license.
+
+     8.4.  In the event of termination under Sections 8.1 or 8.2 above,
+     all end user license agreements (excluding distributors and resellers)
+     which have been validly granted by You or any distributor hereunder
+     prior to termination shall survive termination.
+
+9. LIMITATION OF LIABILITY.
+
+     UNDER NO CIRCUMSTANCES AND UNDER NO LEGAL THEORY, WHETHER TORT
+     (INCLUDING NEGLIGENCE), CONTRACT, OR OTHERWISE, SHALL YOU, THE INITIAL
+     DEVELOPER, ANY OTHER CONTRIBUTOR, OR ANY DISTRIBUTOR OF COVERED CODE,
+     OR ANY SUPPLIER OF ANY OF SUCH PARTIES, BE LIABLE TO ANY PERSON FOR
+     ANY INDIRECT, SPECIAL, INCIDENTAL, OR CONSEQUENTIAL DAMAGES OF ANY
+     CHARACTER INCLUDING, WITHOUT LIMITATION, DAMAGES FOR LOSS OF GOODWILL,
+     WORK STOPPAGE, COMPUTER FAILURE OR MALFUNCTION, OR ANY AND ALL OTHER
+     COMMERCIAL DAMAGES OR LOSSES, EVEN IF SUCH PARTY SHALL HAVE BEEN
+     INFORMED OF THE POSSIBILITY OF SUCH DAMAGES. THIS LIMITATION OF
+     LIABILITY SHALL NOT APPLY TO LIABILITY FOR DEATH OR PERSONAL INJURY
+     RESULTING FROM SUCH PARTY'S NEGLIGENCE TO THE EXTENT APPLICABLE LAW
+     PROHIBITS SUCH LIMITATION. SOME JURISDICTIONS DO NOT ALLOW THE
+     EXCLUSION OR LIMITATION OF INCIDENTAL OR CONSEQUENTIAL DAMAGES, SO
+     THIS EXCLUSION AND LIMITATION MAY NOT APPLY TO YOU.
+
+10. U.S. GOVERNMENT END USERS.
+
+     The Covered Code is a "commercial item," as that term is defined in
+     48 C.F.R. 2.101 (Oct. 1995), consisting of "commercial computer
+     software" and "commercial computer software documentation," as such
+     terms are used in 48 C.F.R. 12.212 (Sept. 1995). Consistent with 48
+     C.F.R. 12.212 and 48 C.F.R. 227.7202-1 through 227.7202-4 (June 1995),
+     all U.S. Government End Users acquire Covered Code with only those
+     rights set forth herein.
+
+11. MISCELLANEOUS.
+
+     This License represents the complete agreement concerning subject
+     matter hereof. If any provision of this License is held to be
+     unenforceable, such provision shall be reformed only to the extent
+     necessary to make it enforceable. This License shall be governed by
+     California law provisions (except to the extent applicable law, if
+     any, provides otherwise), excluding its conflict-of-law provisions.
+     With respect to disputes in which at least one party is a citizen of,
+     or an entity chartered or registered to do business in the United
+     States of America, any litigation relating to this License shall be
+     subject to the jurisdiction of the Federal Courts of the Northern
+     District of California, with venue lying in Santa Clara County,
+     California, with the losing party responsible for costs, including
+     without limitation, court costs and reasonable attorneys' fees and
+     expenses. The application of the United Nations Convention on
+     Contracts for the International Sale of Goods is expressly excluded.
+     Any law or regulation which provides that the language of a contract
+     shall be construed against the drafter shall not apply to this
+     License.
+
+12. RESPONSIBILITY FOR CLAIMS.
+
+     As between Initial Developer and the Contributors, each party is
+     responsible for claims and damages arising, directly or indirectly,
+     out of its utilization of rights under this License and You agree to
+     work with Initial Developer and Contributors to distribute such
+     responsibility on an equitable basis. Nothing herein is intended or
+     shall be deemed to constitute any admission of liability.
+
+13. MULTIPLE-LICENSED CODE.
+
+     Initial Developer may designate portions of the Covered Code as
+     "Multiple-Licensed".  "Multiple-Licensed" means that the Initial
+     Developer permits you to utilize portions of the Covered Code under
+     Your choice of the NPL or the alternative licenses, if any, specified
+     by the Initial Developer in the file described in Exhibit A.
+
+EXHIBIT A -Mozilla Public License.
+
+     ``The contents of this file are subject to the Mozilla Public License
+     Version 1.1 (the "License"); you may not use this file except in
+     compliance with the License. You may obtain a copy of the License at
+     http://www.mozilla.org/MPL/
+
+     Software distributed under the License is distributed on an "AS IS"
+     basis, WITHOUT WARRANTY OF ANY KIND, either express or implied. See the
+     License for the specific language governing rights and limitations
+     under the License.
+
+     The Original Code is ______________________________________.
+
+     The Initial Developer of the Original Code is ________________________.
+     Portions created by ______________________ are Copyright (C) ______
+     _______________________. All Rights Reserved.
+
+     Contributor(s): ______________________________________.
+
+     Alternatively, the contents of this file may be used under the terms
+     of the _____ license (the  "[___] License"), in which case the
+     provisions of [______] License are applicable instead of those
+     above.  If you wish to allow use of your version of this file only
+     under the terms of the [____] License and not to allow others to use
+     your version of this file under the MPL, indicate your decision by
+     deleting  the provisions above and replace  them with the notice and
+     other provisions required by the [___] License.  If you do not delete
+     the provisions above, a recipient may use your version of this file
+     under either the MPL or the [___] License."
+
+     [NOTE: The text of this Exhibit A may differ slightly from the text of
+     the notices in the Source Code files of the Original Code. You should
+     use the text of this Exhibit A rather than the text found in the
+     Original Code Source Code for Your Modifications.]
+

DISPLAYER/Displayer.app/Adobe AIR/Versions/1.0/Resources/Licenses/pcre2/COPYING

@@ -0,0 +1,5 @@
+PCRE2 LICENCE
+
+Please see the file LICENCE in the PCRE2 distribution for licensing details.
+
+End

DISPLAYER/Displayer.app/Adobe AIR/Versions/1.0/Resources/Licenses/pixman/COPYING

@@ -0,0 +1,42 @@
+The following is the MIT license, agreed upon by most contributors.
+Copyright holders of new code should use this license statement where
+possible. They may also add themselves to the list below.
+
+/*
+ * Copyright 1987, 1988, 1989, 1998  The Open Group
+ * Copyright 1987, 1988, 1989 Digital Equipment Corporation
+ * Copyright 1999, 2004, 2008 Keith Packard
+ * Copyright 2000 SuSE, Inc.
+ * Copyright 2000 Keith Packard, member of The XFree86 Project, Inc.
+ * Copyright 2004, 2005, 2007, 2008, 2009, 2010 Red Hat, Inc.
+ * Copyright 2004 Nicholas Miell
+ * Copyright 2005 Lars Knoll & Zack Rusin, Trolltech
+ * Copyright 2005 Trolltech AS
+ * Copyright 2007 Luca Barbato
+ * Copyright 2008 Aaron Plattner, NVIDIA Corporation
+ * Copyright 2008 Rodrigo Kumpera
+ * Copyright 2008 André Tupinambá
+ * Copyright 2008 Mozilla Corporation
+ * Copyright 2008 Frederic Plourde
+ * Copyright 2009, Oracle and/or its affiliates. All rights reserved.
+ * Copyright 2009, 2010 Nokia Corporation
+ *
+ * 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 (including the next
+ * paragraph) 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.
+ */

DISPLAYER/Displayer.app/META-INF/AIR/application.xml

@@ -0,0 +1,38 @@
+<?xml version="1.0" encoding="utf-8" standalone="no" ?>
+<!-- 
+	Usage:
+
+	To localize the description, use the following format for the description element.
+	<description>
+	<text xml:lang="en">English App description goes here</text>
+	<text xml:lang="fr">French App description goes here</text>
+	<text xml:lang="ja">Japanese App description goes here</text>
+	</description>
+
+	To localize the name, use the following format for the name element.
+	<name>
+	<text xml:lang="en">English App name goes here</text>
+	<text xml:lang="fr">French App name goes here</text>
+	<text xml:lang="ja">Japanese App name goes here</text>
+	</name>
+-->
+<application xmlns="http://ns.adobe.com/air/application/50.2">
+  <id>Displayer</id>
+  <versionNumber>1.0</versionNumber>
+  <filename>Displayer</filename>
+  <description/>
+  <name>Displayer</name>
+  <copyright/>
+  <initialWindow>
+    <content>Displayer.swf</content>
+    <systemChrome>standard</systemChrome>
+    <transparent>false</transparent>
+    <visible>true</visible>
+    <fullScreen>false</fullScreen>
+    <aspectRatio>portrait</aspectRatio>
+    <renderMode>auto</renderMode>
+  </initialWindow>
+  <icon/>
+  <customUpdateUI>false</customUpdateUI>
+  <allowBrowserInvocation>false</allowBrowserInvocation>
+</application>

DISPLAYER/Displayer.app/META-INF/AIR/hash

@@ -0,0 +1 @@
+*�x�\4�b�?ʈϱm���D��R�V�

DISPLAYER/Displayer.app/META-INF/signatures.xml

@@ -0,0 +1,125 @@
+<signatures>
+  <Signature xmlns="http://www.w3.org/2000/09/xmldsig#" Id="PackageSignature">
+    <SignedInfo>
+      <CanonicalizationMethod Algorithm="http://www.w3.org/TR/2001/REC-xml-c14n-20010315"/>
+      <SignatureMethod Algorithm="http://www.w3.org/TR/xmldsig-core#rsa-sha1"/>
+      <Reference URI="#PackageContents">
+        <Transforms>
+          <Transform Algorithm="http://www.w3.org/TR/2001/REC-xml-c14n-20010315"/>
+        </Transforms>
+        <DigestMethod Algorithm="http://www.w3.org/2001/04/xmlenc#sha256"/>
+        <DigestValue>8JU2vTHQXxN+oG7ajfcPThFxZw+4HaE/W1R701X0HmI=</DigestValue>
+      </Reference>
+    </SignedInfo>
+    <SignatureValue Id="PackageSignatureValue">Mh+++p7/aMCK6BDStU/uDfzIIDCkrRNIXilx77yZefzun3+wxjcDJgw5HQWfNe0HU+WzOBQTaVQE
+g+hg36BRV5Nnt1r+aMuFnJ1VPck6oBR4zjcyhUa2flUHa5iki1hXXSYO+451XDXwsE8cWri4V7bj
+cHw573SbPOUZsQ3VeQ1mw4WAlrKVPX4nE9sBQXqXmLqk73sFIxalKI9LnjGeHFsOWjbgauqnNF7r
+kE4ANsyRAkwK8ypWeuvY9T6Yi4pL/K4q7uSi81xFwv6Cmdj9/f00N1JukBrnkIRM87sx53F3+Pse
+7ahqlLuuGXazzSzZ7MaQS0xLqePgOQXkR+z2ng==</SignatureValue>
+    <KeyInfo>
+      <X509Data>
+        <X509Certificate>MIIDNTCCAh2gAwIBAgIYODVmMDU4OjE4Zjg4NzgxZDQ2Oi04MDAwMA0GCSqGSIb3DQEBCwUAMEYx
+CzAJBgNVBAYTAlVTMREwDwYDVQQKEwhJbm1lbnRhbDERMA8GA1UECxMISW5tZW50YWwxETAPBgNV
+BAMTCElubWVudGFsMB4XDTI0MDUxNjIxMzIwNFoXDTQ5MDUxNzIxMzIwNFowRjELMAkGA1UEBhMC
+VVMxETAPBgNVBAoTCElubWVudGFsMREwDwYDVQQLEwhJbm1lbnRhbDERMA8GA1UEAxMISW5tZW50
+YWwwggEiMA0GCSqGSIb3DQEBAQUAA4IBDwAwggEKAoIBAQCd5NZFzGtSp1bMuO9F96YKJdl92UnG
+oBj8cj2rZsjMMyK+lcoiy4oWDFsqSLJoouJ3fRd1Gi56tqPlUyLSOfvGUbJk9IAh49KJYIdIqX18
+GYq+FAlXS4zxvTs1rSQPly7eE495zYrW9CkVfSIl7BrNdQOPDoAg2JO2QhucUHom4fpd3amuitxD
+4QISGrzurLW6WHK5zFAnCKeO/CErOT0VV25SplRU/tr9xf9bQf0QEiS9hbuW1ZJh1P5MN9I3YUoV
+70gdFghnlgpsvmiA5j0zZdEFvj24+88o0FgL9gpZOsz/ezSRKC130GoNX0GNWIQLTgSAlWmfC/Yb
+y5Ec2z7BAgMBAAGjFzAVMBMGA1UdJQQMMAoGCCsGAQUFBwMDMA0GCSqGSIb3DQEBCwUAA4IBAQCK
+BcC/oA6as+QAJCzq5GeQxBnmfdlcPtOmfnIDv2yHpUw2gWnK0T9mH5XRfZsPb3y0l8EGTglMVm/S
+gKrj6/HaS+d7Rvth8NNh4PmB1n5Tr2hh0ZdiK25Ph/Tc4GGk03j1FLcfy/Hanm137y1A2DpVdpch
+YZs2LNorpdcqqjSgV4kHuMHtr5oL3fhD5Pgajoiy26vnslXsEjqqBgiwuc+3thN/rPWhQU2sLnzZ
+Batun4MoatD0BGXT/VtJAYG8fJvQPyhNLrM8eXITl2/tkBHk3Mpd7ZMSe9WJbhLhp71OdK85XXo1
+tRZggoqrlXN+3CJipLneIVlisSwqE4yB6hHs</X509Certificate>
+      </X509Data>
+    </KeyInfo>
+    <Object>
+      <Manifest Id="PackageContents">
+        <Reference URI="Displayer.swf"><DigestMethod Algorithm="http://www.w3.org/2001/04/xmlenc#sha256"></DigestMethod><DigestValue>iukCSL+g97J7EboaWUezqKdwUou3wnQCYx8+27b24Bg=</DigestValue></Reference><Reference URI="META-INF/AIR/application.xml"><DigestMethod Algorithm="http://www.w3.org/2001/04/xmlenc#sha256"></DigestMethod><DigestValue>b2hRKplC0bw3Cp0DaigsxuOcCGsL1RRnkYUxZ/hQOMY=</DigestValue></Reference><Reference URI="config.json"><DigestMethod Algorithm="http://www.w3.org/2001/04/xmlenc#sha256"></DigestMethod><DigestValue>DHqY+sRs8drd4UUTYbab/OJkPSajd5CrU8r49eur8bE=</DigestValue></Reference><Reference URI="mimetype"><DigestMethod Algorithm="http://www.w3.org/2001/04/xmlenc#sha256"></DigestMethod><DigestValue>0/oCb84THKMagtI0Dy0KogEu92TegdesqRr/clXct1c=</DigestValue></Reference>
+      </Manifest>
+    </Object>
+    <Object xmlns:xades="http://uri.etsi.org/01903/v1.1.1#" > 
+  <xades:QualifyingProperties>
+    <xades:UnsignedProperties > 
+      <xades:UnsignedSignatureProperties>
+        <xades:SignatureTimeStamp>
+     	  <xades:HashDataInfo uri="#PackageSignatureValue">
+     	    <Transforms>
+          	  <Transform Algorithm="http://www.w3.org/TR/2001/REC-xml-c14n-20010315"/>
+            </Transforms>
+            <xades:EncapsulatedTimeStamp>
+              MIIOEwYJKoZIhvcNAQcCoIIOBDCCDgACAQMxDTALBglghkgBZQMEAgEwgf4GCyqGSIb3DQEJEAEE
+oIHuBIHrMIHoAgEBBgtghkgBhvhFAQcXAzAhMAkGBSsOAwIaBQAEFJo2K9rurjIHaAT9QMO+qs4h
+kp8dAhQhfTO+0bRYfMJ9WP0qlqG5X2d3WRgPMjAyNDA4MTQxNzI5MDNaMAMCAR6ggYakgYMwgYAx
+CzAJBgNVBAYTAlVTMR0wGwYDVQQKExRTeW1hbnRlYyBDb3Jwb3JhdGlvbjEfMB0GA1UECxMWU3lt
+YW50ZWMgVHJ1c3QgTmV0d29yazExMC8GA1UEAxMoU3ltYW50ZWMgU0hBMjU2IFRpbWVTdGFtcGlu
+ZyBTaWduZXIgLSBHM6CCCoswggU4MIIEIKADAgECAhB7BbHUSWhRRPfJidKcGZ0SMA0GCSqGSIb3
+DQEBCwUAMIG9MQswCQYDVQQGEwJVUzEXMBUGA1UEChMOVmVyaVNpZ24sIEluYy4xHzAdBgNVBAsT
+FlZlcmlTaWduIFRydXN0IE5ldHdvcmsxOjA4BgNVBAsTMShjKSAyMDA4IFZlcmlTaWduLCBJbmMu
+IC0gRm9yIGF1dGhvcml6ZWQgdXNlIG9ubHkxODA2BgNVBAMTL1ZlcmlTaWduIFVuaXZlcnNhbCBS
+b290IENlcnRpZmljYXRpb24gQXV0aG9yaXR5MB4XDTE2MDExMjAwMDAwMFoXDTMxMDExMTIzNTk1
+OVowdzELMAkGA1UEBhMCVVMxHTAbBgNVBAoTFFN5bWFudGVjIENvcnBvcmF0aW9uMR8wHQYDVQQL
+ExZTeW1hbnRlYyBUcnVzdCBOZXR3b3JrMSgwJgYDVQQDEx9TeW1hbnRlYyBTSEEyNTYgVGltZVN0
+YW1waW5nIENBMIIBIjANBgkqhkiG9w0BAQEFAAOCAQ8AMIIBCgKCAQEAu1mdWVVPnYxyXRqBoutV
+87ABrTxxrDKPBWuGmicAMpdqTclkFEspu8LZKbku7GOz4c8/C1aQ+GIbfuumB+Lef15tQDjUkQbn
+QXx5HMvLrRu/2JWR8/DubPitljkuf8EnuHg5xYSl7e2vh47Ojcdt6tKYtTofHjmdw/SaqPSE4cTR
+fHHGBim0P+SDDSbDewg+TfkKtzNJ/8o71PWym0vhiJka9cDpMxTW38eA25Hu/rySV3J39M2ozP4J
+9ZM3vpWIasXc9LFL1M7oCZFftYR5NYp4rBkyjyPBMkEbWQ6pPrHM+dYr77fY5NUdbRE6kvaTyZzj
+SO67Uw7UNpeGeMWhNwIDAQABo4IBdzCCAXMwDgYDVR0PAQH/BAQDAgEGMBIGA1UdEwEB/wQIMAYB
+Af8CAQAwZgYDVR0gBF8wXTBbBgtghkgBhvhFAQcXAzBMMCMGCCsGAQUFBwIBFhdodHRwczovL2Qu
+c3ltY2IuY29tL2NwczAlBggrBgEFBQcCAjAZGhdodHRwczovL2Quc3ltY2IuY29tL3JwYTAuBggr
+BgEFBQcBAQQiMCAwHgYIKwYBBQUHMAGGEmh0dHA6Ly9zLnN5bWNkLmNvbTA2BgNVHR8ELzAtMCug
+KaAnhiVodHRwOi8vcy5zeW1jYi5jb20vdW5pdmVyc2FsLXJvb3QuY3JsMBMGA1UdJQQMMAoGCCsG
+AQUFBwMIMCgGA1UdEQQhMB+kHTAbMRkwFwYDVQQDExBUaW1lU3RhbXAtMjA0OC0zMB0GA1UdDgQW
+BBSvY9bKo06FcuCnvEHzKaI4f4B1YjAfBgNVHSMEGDAWgBS2d/ppSEefUxLVwuoHMnYH0ZcHGTAN
+BgkqhkiG9w0BAQsFAAOCAQEAdeqwLdU0GVwyRf4O4dRPpnjBb9fq3dxP86HIgYj3p48V5kApreZd
+9KLZVmSEcTAq3R5hF2YgVgaYGY1dcfL4l7wJ/RyRR8ni6I0D+8yQL9YKbE4z7Na0k8hMkGNIOUAh
+xN3WbomYPLWYl+ipBrcJyY9TV0GQL+EeTU7cyhB4bEJu8LbF+GFcUvVO9muN90p6vvPN/QPX2fYD
+qA/jU/cKdezGdS6qZoUEmbf4Blfhxg726K/a7JsYH6q54zoAv86KlMsB257HOLsPUqvR45QDYApN
+oP4nbRQy/D+XQOG/mYnb5DkUvdrk08PqK1qzlVhVBH3HmuwjA42FKtL/rqlhgTCCBUswggQzoAMC
+AQICEHvU5a+6zAc/oQEjBCJBTRIwDQYJKoZIhvcNAQELBQAwdzELMAkGA1UEBhMCVVMxHTAbBgNV
+BAoTFFN5bWFudGVjIENvcnBvcmF0aW9uMR8wHQYDVQQLExZTeW1hbnRlYyBUcnVzdCBOZXR3b3Jr
+MSgwJgYDVQQDEx9TeW1hbnRlYyBTSEEyNTYgVGltZVN0YW1waW5nIENBMB4XDTE3MTIyMzAwMDAw
+MFoXDTI5MDMyMjIzNTk1OVowgYAxCzAJBgNVBAYTAlVTMR0wGwYDVQQKExRTeW1hbnRlYyBDb3Jw
+b3JhdGlvbjEfMB0GA1UECxMWU3ltYW50ZWMgVHJ1c3QgTmV0d29yazExMC8GA1UEAxMoU3ltYW50
+ZWMgU0hBMjU2IFRpbWVTdGFtcGluZyBTaWduZXIgLSBHMzCCASIwDQYJKoZIhvcNAQEBBQADggEP
+ADCCAQoCggEBAK8Oiqr43L9pe1QXcUcJvY08gfh0FXdnkJz93k4Cnkt29uU2PmXVJCBtMPndHYPp
+PydKM05tForkjUCNIqq+pwsb0ge2PLUaJCj4G3JRPcgJiCYIOvn6QyN1R3AMs19bjwgdckhXZU2v
+AjxA9/TdMjiTP+UspvNZI8uA3hNN+RDJqgoYbFVhV9HxAizEtavybCPSnw0PGWythWJp/U6FwYpS
+Matb2Ml0UuNXbCK/VX9vygarP0q3InZl7Ow28paVgSYs/buYqgE4068lQJsJU/ApV4VYXuqFSEEh
+h+XetNMmsntAU1h5jlIxBk2UA0XEzjwD7LcA8joixbRv5e+wipsCAwEAAaOCAccwggHDMAwGA1Ud
+EwEB/wQCMAAwZgYDVR0gBF8wXTBbBgtghkgBhvhFAQcXAzBMMCMGCCsGAQUFBwIBFhdodHRwczov
+L2Quc3ltY2IuY29tL2NwczAlBggrBgEFBQcCAjAZGhdodHRwczovL2Quc3ltY2IuY29tL3JwYTBA
+BgNVHR8EOTA3MDWgM6Axhi9odHRwOi8vdHMtY3JsLndzLnN5bWFudGVjLmNvbS9zaGEyNTYtdHNz
+LWNhLmNybDAWBgNVHSUBAf8EDDAKBggrBgEFBQcDCDAOBgNVHQ8BAf8EBAMCB4AwdwYIKwYBBQUH
+AQEEazBpMCoGCCsGAQUFBzABhh5odHRwOi8vdHMtb2NzcC53cy5zeW1hbnRlYy5jb20wOwYIKwYB
+BQUHMAKGL2h0dHA6Ly90cy1haWEud3Muc3ltYW50ZWMuY29tL3NoYTI1Ni10c3MtY2EuY2VyMCgG
+A1UdEQQhMB+kHTAbMRkwFwYDVQQDExBUaW1lU3RhbXAtMjA0OC02MB0GA1UdDgQWBBSlEwGpn4XM
+G24WHl87Map5NgB7HTAfBgNVHSMEGDAWgBSvY9bKo06FcuCnvEHzKaI4f4B1YjANBgkqhkiG9w0B
+AQsFAAOCAQEARp6v8LiiX6KZSM+oJ0shzbK5pnJwYy/jVSl7OUZO535lBliLvFeKkg0I2BC6NiT6
+Cnv7O9Niv0qUFeaC24pUbf8o/mfPcT/mMwnZolkQ9B5K/mXM3tRr41IpdQBKK6XMy5voqU33tBdZ
+kkHDtz+G5vbAf0Q8RlwXWuOkO9VpJtUhfeGAZ35irLdOLhWa5Zwjr1sR6nGpQfkNeTipoQ3PtLHa
+Ppp6xyLFdM3fRwmGxPyRJbIblumFCOjd6nRgbmClVnoNyERY3Ob5SBSe5b/eAL13sZgUchQk38cR
+LB8AP8NLFMZnHMweBqOQX1xUiz7jM1uCD8W3hgJOcZ/pZkU/djGCAlowggJWAgEBMIGLMHcxCzAJ
+BgNVBAYTAlVTMR0wGwYDVQQKExRTeW1hbnRlYyBDb3Jwb3JhdGlvbjEfMB0GA1UECxMWU3ltYW50
+ZWMgVHJ1c3QgTmV0d29yazEoMCYGA1UEAxMfU3ltYW50ZWMgU0hBMjU2IFRpbWVTdGFtcGluZyBD
+QQIQe9Tlr7rMBz+hASMEIkFNEjALBglghkgBZQMEAgGggaQwGgYJKoZIhvcNAQkDMQ0GCyqGSIb3
+DQEJEAEEMBwGCSqGSIb3DQEJBTEPFw0yNDA4MTQxNzI5MDNaMC8GCSqGSIb3DQEJBDEiBCBf4Q1o
+ml1a1/pJWAt7zhA6V0XBdEYe4uY/cHls7QwUOTA3BgsqhkiG9w0BCRACLzEoMCYwJDAiBCDEdM52
+AH0COU4NpeTefBTGgPniggE8/vZT7123H99h+DALBgkqhkiG9w0BAQEEggEAC1vvkBB4O8KBEkyE
+jlHgNSBFq+GUENZsNLC6vdM+elXtDcMffPOeCAR7SI+iAObHinCFrfoG33dp1vIJqr4CT1vzDgHg
+9i4HLoja/57MpjkvWplCqzgfyFXoeIqwv4cdjKzLlGRk+3Vtq3OBbiF/yuR1ADsmb0y2Km/vdZ7E
+SDwUABFwQeD0dUdvm6XHpK8/Y74xHPjuLJIPe65ZuwuzsJsw2IpzG9xjlBPl8JtGNMMvZrItLG3t
+Jbw9rW0m1o5wlguxOFzgaXW10RIOmffnR2lcfMVfdokPtpFNoRcesqxDBpBM7hFRTyiRHeG1StiF
+K4462jFHhxW0RZ9t2mAgeg==
+            </xades:EncapsulatedTimeStamp>     	
+     	  </xades:HashDataInfo>     	
+        </xades:SignatureTimeStamp>
+      </xades:UnsignedSignatureProperties> 
+    </xades:UnsignedProperties>
+  </xades:QualifyingProperties>
+</Object>
+  </Signature>
+</signatures>

DISPLAYER/Displayer.app/config.json

@@ -0,0 +1,11 @@
+{
+    "api_url": "http://127.0.0.1:5000",
+    "size": {
+        "width": 1920,
+        "height": 1080
+    },
+    "position": {
+        "x": 0,
+        "y": 0
+    }
+}

DISPLAYER/Displayer.app/mimetype

@@ -0,0 +1 @@
+application/vnd.adobe.air-application-installer-package+zip

DISPLAYER/FullScreenImageLoader.as

@@ -0,0 +1,149 @@
+ package {
+    import flash.display.*;
+    import flash.events.*;
+    import flash.net.*;
+    import flash.utils.*;
+    import flash.text.*;
+    import com.adobe.images.PNGEncoder;
+    import com.adobe.crypto.MD5;
+    import com.sociodox.utils.Base64;
+    import flash.filesystem.File;
+    import flash.filesystem.FileStream;
+    import flash.filesystem.FileMode;
+    
+    public class FullScreenImageLoader extends Sprite {
+        private var apiUrl:String;
+        private var imageWidth:int;
+        private var imageHeight:int;
+        private var imageX:int;
+        private var imageY:int;
+        private var refreshInterval:int = 2000; // Refresh every 2 seconds
+        private var timer:Timer;
+        private var bitmap:Bitmap;
+        private var currentChecksum:String = ""; // Store the checksum of the currently displayed image
+        private var errorMessage:TextField;
+
+        public function FullScreenImageLoader() {
+            stage.scaleMode = StageScaleMode.NO_SCALE;
+            stage.align = StageAlign.TOP_LEFT;
+            stage.displayState = StageDisplayState.FULL_SCREEN;
+
+            // Load configuration from JSON file
+            loadConfig();
+
+            bitmap = new Bitmap();
+            addChild(bitmap);
+
+            // Set up the timer to refresh the image
+            timer = new Timer(refreshInterval);
+            timer.addEventListener(TimerEvent.TIMER, onTimer);
+            timer.start();
+
+            // Create an error message text field for display
+            errorMessage = new TextField();
+            errorMessage.defaultTextFormat = new TextFormat("Arial", 20, 0xFF0000);
+            errorMessage.width = stage.stageWidth;
+            errorMessage.height = 50;
+            errorMessage.y = stage.stageHeight - 50;
+            errorMessage.selectable = false;
+            addChild(errorMessage);
+
+            // Initial load
+            loadImage();
+        }
+
+        private function loadConfig():void {
+            var configFile:File = File.applicationDirectory.resolvePath("config.json");
+            if (configFile.exists) {
+                var fileStream:FileStream = new FileStream();
+                fileStream.open(configFile, FileMode.READ);
+                var configData:String = fileStream.readUTFBytes(fileStream.bytesAvailable);
+                fileStream.close();
+
+                var config:Object = JSON.parse(configData);
+                apiUrl = config.api_url;
+                imageWidth = config.size.width;
+                imageHeight = config.size.height;
+                imageX = config.position.x;
+                imageY = config.position.y;
+
+                trace("Configuration loaded: ", apiUrl, imageWidth, imageHeight, imageX, imageY);
+            } else {
+                trace("Config file not found: config.json");
+                errorMessage.text = "Config file not found: config.json";
+            }
+        }
+
+        private function onTimer(event:TimerEvent):void {
+            loadImage();
+        }
+
+        private function loadImage():void {
+            var request:URLRequest = new URLRequest(apiUrl + "/get_status");
+            var loader:URLLoader = new URLLoader();
+            loader.dataFormat = URLLoaderDataFormat.TEXT;
+            loader.addEventListener(Event.COMPLETE, onImageLoadComplete);
+            loader.addEventListener(IOErrorEvent.IO_ERROR, onIOError);
+            loader.load(request);
+        }
+
+        private function onImageLoadComplete(event:Event):void {
+            var loader:URLLoader = URLLoader(event.target);
+            try {
+                var response:Object = JSON.parse(loader.data);
+
+                if (response.hasOwnProperty("checksum")) {
+                    var newChecksum:String = response.checksum;
+
+                    // Compare checksums, if different, update the image
+                    if (newChecksum != currentChecksum) {
+                        currentChecksum = newChecksum;
+
+                        if (response.hasOwnProperty("image_base64") && response.image_base64 != "") {
+                            displayNewImage(response.image_base64);
+                        } else {
+                            trace("No image data found.");
+                            errorMessage.text = "No image data found.";
+                        }
+                    }
+                } else {
+                    trace("Invalid response from server.");
+                    errorMessage.text = "Invalid response from server.";
+                }
+            } catch (error:Error) {
+                trace("Error parsing response: " + error.message);
+                errorMessage.text = "Error parsing response: " + error.message;
+            }
+        }
+
+        private function displayNewImage(base64Image:String):void {
+            try {
+                var byteArray:ByteArray = Base64.decode(base64Image);
+                var loader:Loader = new Loader();
+                loader.contentLoaderInfo.addEventListener(Event.COMPLETE, onImageDecoded);
+                loader.loadBytes(byteArray);
+            } catch (error:Error) {
+                trace("Error decoding image: " + error.message);
+                errorMessage.text = "Error decoding image: " + error.message;
+            }
+        }
+
+         private function onImageDecoded(event:Event):void {
+            var loader:Loader = Loader(event.target.loader);
+            var bitmapData:BitmapData = Bitmap(loader.content).bitmapData;
+
+            // Update the display
+            bitmap.bitmapData = bitmapData;
+            bitmap.width = imageWidth;
+            bitmap.height = imageHeight;
+            bitmap.x = imageX;
+            bitmap.y = imageY;
+            bitmap.smoothing = true;
+        }
+
+        private function onIOError(event:IOErrorEvent):void {
+            trace("Error loading image: " + event.text);
+            errorMessage.text = "Error loading image: " + event.text;
+        }
+    }
+}

DISPLAYER/Main.as

@@ -0,0 +1 @@
+

DISPLAYER/com/adobe/air/crypto/EncryptionKeyGenerator.as

@@ -0,0 +1,313 @@
+/*
+  Copyright (c) 2009, 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.crypto
+{
+	import com.adobe.crypto.SHA256;
+	
+	import flash.data.EncryptedLocalStore;
+	import flash.utils.ByteArray;
+			
+	/**
+	 * The EncryptionKeyGenerator class generates an encryption key value, such as you would use 
+	 * to encrypt files or data. For example, the encryption key is suitable to use as 
+	 * an encryption key for an encrypted AIR local SQL (SQLite) database.
+	 * 
+	 * <p>This class uses techniques and algorithms that are designed for maximum 
+	 * data privacy and security. Use this class to generate an encryption key if your 
+	 * application requires data to be encrypted on a per-user level (in other words, 
+	 * if only one user of the application should be able to access his or her data). 
+	 * In some situations you may also want to use per-user encryption for data even 
+	 * if the application design specifies that other users can access the data. For more 
+	 * information, see 
+	 * "<a href="http://help.adobe.com/en_US/AIR/1.5/devappsflex/WS34990ABF-C893-47ec-B813-9C9D9587A398.html">Considerations for using encryption with a database</a>" 
+	 * in the guide 
+	 * "<a href="http://help.adobe.com/en_US/AIR/1.5/devappsflex/">Developing Adobe AIR Applications with Flex</a>."</p>
+	 * 
+	 * <p>The generated encryption key is based on a password that you provide. For any given 
+	 * password, in the same AIR application 
+	 * running in the same user account on the same machine, the encryption key result is 
+	 * the same.</p>
+	 * 
+	 * <p>To generate an encryption key from a password, use the <code>getEncryptionKey()</code> 
+	 * method. To confirm that a password is a "strong" password before calling the 
+	 * <code>getEncryptionKey()</code> method, use the <code>validateStrongPassword()</code> 
+	 * method.</p>
+	 * 
+	 * <p>In addition, the EncryptionKeyGenerator includes a utility constant, 
+	 * <code>ENCRYPTED_DB_PASSWORD_ERROR_ID</code>. This constant matches the error ID of 
+	 * the SQLError error that occurs when code that is attempting to open an encrypted database 
+	 * provides the wrong encryption key.</p>
+	 * 
+	 * <p>This class is designed to create an encryption key suitable for providing the highest 
+	 * level of data privacy and security. In order to achieve that level of security, a few 
+	 * security principles must be followed:</p>
+	 * 
+	 * <ul>
+	 *   <li>Your application should never store the user-entered password</li>
+	 *   <li>Your application should never store the encryption key returned by the 
+	 *       <code>getEncryptionKey()</code> method.</li>
+	 *   <li>Instead, each time the user runs the application and attempts to access the database, 
+	 *       your application code should call the <code>getEncryptionKey()</code> method to 
+	 *       regenerate the encryption key.</li>
+	 * </ul>
+	 * 
+	 * <p>For more information about data security, and an explanation of the security techniques 
+	 * used in the EncryptionKeyGenerator class, see 
+	 * "<a href="http://help.adobe.com/en_US/AIR/1.5/devappsflex/WS61068DCE-9499-4d40-82B8-B71CC35D832C.html">Example: Generating and using an encryption key</a>" 
+	 * in the guide 
+	 * "<a href="http://help.adobe.com/en_US/AIR/1.5/devappsflex/">Developing Adobe AIR Applications with Flex</a>."</p>
+	 */
+	public class EncryptionKeyGenerator
+	{
+		// ------- Constants -------
+		/**
+		 * This constant matches the error ID (3138) of the SQLError error that occurs when 
+		 * code that is attempting to open an encrypted database provides the wrong 
+		 * encryption key.
+		 */
+		public static const ENCRYPTED_DB_PASSWORD_ERROR_ID:uint = 3138;
+		
+		private static const STRONG_PASSWORD_PATTERN:RegExp = /(?=^.{8,32}$)((?=.*\d)|(?=.*\W+))(?![.\n])(?=.*[A-Z])(?=.*[a-z]).*$/;
+		private static const SALT_ELS_KEY:String = "com.adobe.air.crypto::EncryptedDBSalt$$$";
+		
+		
+		// ------- Constructor -------
+		
+		/**
+		 * Creates a new EncryptionKeyGenerator instance.
+		 */
+		public function EncryptionKeyGenerator() {}
+		
+		
+		// ------- Public methods -------
+		
+		/**
+		 * Checks a password and returns a value indicating whether the password is a "strong" 
+		 * password. The criteria for a strong password are:
+		 * 
+		 * <ul>
+		 *   <li>Minimum 8 characters</li>
+		 *   <li>Maxmium 32 characters</li>
+		 *   <li>Contains at least one lowercase letter</li>
+		 *   <li>Contains at least one uppercase letter</li>
+		 *   <li>Contains at least one number or symbol character</li>
+		 * </ul>
+		 * 
+		 * @param password The password to check
+		 * 
+		 * @return A value indicating whether the password is a strong password (<code>true</code>) 
+		 * or not (<code>false</code>).
+		 */
+		public function validateStrongPassword(password:String):Boolean
+		{
+			if (password == null || password.length <= 0)
+			{
+				return false;
+			}
+			
+			return STRONG_PASSWORD_PATTERN.test(password);
+		}
+		
+		
+		/**
+		 * Uses a password to generate a 16-byte encryption key. The return value is suitable 
+		 * to use as an encryption key for an encrypted AIR local SQL (SQLite) database.
+		 * 
+		 * <p>For any given 
+		 * password, calling the <code>getEncryptionKey()</code> method from the same AIR application 
+		 * running in the same user account on the same machine, the encryption key result is 
+		 * the same.</p>
+		 * 
+		 * <p>This method is designed to create an encryption key suitable for providing the highest 
+		 * level of data privacy and security. In order to achieve that level of security, your 
+		 * application must follow several security principles:</p>
+		 * 
+		 * <ul>
+		 *   <li>Your application can never store the user-entered password</li>
+		 *   <li>Your application can never store the encryption key returned by the 
+		 *       <code>getEncryptionKey()</code> method.</li>
+		 *   <li>Instead, each time the user runs the application and attempts to access the database, 
+		 *       call the <code>getEncryptionKey()</code> method to regenerate the encryption key.</li>
+		 * </ul>
+		 * 
+		 * <p>For more information about data security, and an explanation of the security techniques 
+		 * used in the EncryptionKeyGenerator class, see 
+		 * "<a href="http://help.adobe.com/en_US/AIR/1.5/devappsflex/WS61068DCE-9499-4d40-82B8-B71CC35D832C.html">Example: Generating and using an encryption key</a>" 
+		 * in the guide 
+		 * "<a href="http://help.adobe.com/en_US/AIR/1.5/devappsflex/">Developing Adobe AIR Applications with Flex</a>."</p>
+		 * 
+		 * @param password	The password to use to generate the encryption key.
+		 * @param overrideSaltELSKey	The EncryptionKeyGenerator creates and stores a random value 
+		 * 								(known as a <i>salt</i>) as part of the process of 
+		 * 								generating the encryption key. The first time an application 
+		 * 								calls the <code>getEncryptionKey()</code> method, the salt 
+		 * 								value is created and stored in the AIR application's encrypted 
+		 * 								local store (ELS). From then on, the salt value is loaded from the 
+		 * 								ELS.
+		 * 								<p>If you wish to provide a custom String ELS key for storing 
+		 * 								the salt value, specify a value for the <code>overrideSaltELSKey</code>
+		 * 								parameter. If the parameter is <code>null</code> (the default) 
+		 * 								a default key name is used.</p>
+		 * 
+		 * @return The generated encryption key, a 16-byte ByteArray object.
+		 * 
+		 * @throws ArgumentError	If the specified password is not a "strong" password according to the 
+		 * 							criteria explained in the <code>validateStrongPassword()</code> 
+		 * 							method description
+		 * 
+		 * @throws ArgumentError	If a non-<code>null</code> value is specified for the <code>overrideSaltELSKey</code>
+		 * 							parameter, and the value is an empty String (<code>""</code>)
+		 */
+		public function getEncryptionKey(password:String, overrideSaltELSKey:String=null):ByteArray
+		{
+			if (!validateStrongPassword(password))
+			{
+				throw new ArgumentError("The password must be a strong password. It must be 8-32 characters long. It must contain at least one uppercase letter, at least one lowercase letter, and at least one number or symbol.");
+			}
+			
+			if (overrideSaltELSKey != null && overrideSaltELSKey.length <= 0)
+			{
+				throw new ArgumentError("If an overrideSaltELSKey parameter value is specified, it can't be an empty String.");
+			}
+			
+			var concatenatedPassword:String = concatenatePassword(password);
+			
+			var saltKey:String;
+			if (overrideSaltELSKey == null)
+			{
+				saltKey = SALT_ELS_KEY;
+			}
+			else
+			{
+				saltKey = overrideSaltELSKey;
+			}
+			
+			var salt:ByteArray = EncryptedLocalStore.getItem(saltKey);
+			if (salt == null)
+			{
+				salt = makeSalt();
+				EncryptedLocalStore.setItem(saltKey, salt);
+			}
+			
+			var unhashedKey:ByteArray = xorBytes(concatenatedPassword, salt);
+			
+			var hashedKey:String = SHA256.hashBytes(unhashedKey);
+			
+			var encryptionKey:ByteArray = generateEncryptionKey(hashedKey);
+			
+			return encryptionKey;
+		}
+		
+		
+		// ------- Creating encryption key -------
+		
+		private function concatenatePassword(pwd:String):String
+		{
+			var len:int = pwd.length;
+			var targetLength:int = 32;
+			
+			if (len == targetLength)
+			{
+				return pwd;
+			}
+			
+			var repetitions:int = Math.floor(targetLength / len);
+			var excess:int = targetLength % len;
+			
+			var result:String = "";
+			
+			for (var i:uint = 0; i < repetitions; i++)
+			{
+				result += pwd;
+			}
+			
+			result += pwd.substr(0, excess);
+			
+			return result;
+		}
+		
+		
+		private function makeSalt():ByteArray
+		{
+			var result:ByteArray = new ByteArray;
+			
+			for (var i:uint = 0; i < 8; i++)
+			{
+				result.writeUnsignedInt(Math.round(Math.random() * uint.MAX_VALUE));
+			}
+			
+			return result;
+		}
+		
+		
+		private function xorBytes(passwordString:String, salt:ByteArray):ByteArray
+		{
+			var result:ByteArray = new ByteArray();
+			
+			for (var i:uint = 0; i < 32; i += 4)
+			{
+				// Extract 4 bytes from the password string and convert to a uint
+				var o1:uint = passwordString.charCodeAt(i) << 24;
+				o1 += passwordString.charCodeAt(i + 1) << 16;
+				o1 += passwordString.charCodeAt(i + 2) << 8;
+				o1 += passwordString.charCodeAt(i + 3);
+				
+				salt.position = i;
+				var o2:uint = salt.readUnsignedInt();
+				
+				var xor:uint = o1 ^ o2;
+				result.writeUnsignedInt(xor);
+			}
+			
+			return result;
+		}
+		
+		
+		private function generateEncryptionKey(hash:String):ByteArray
+		{
+			var result:ByteArray = new ByteArray();
+			
+			// select a range of 128 bits (32 hex characters) from the hash
+			// In this case, we'll use the bits starting from position 17
+			for (var i:uint = 0; i < 32; i += 2)
+			{
+				var position:uint = i + 17;
+				var hex:String = hash.substr(position, 2);
+				var byte:int = parseInt(hex, 16);
+				result.writeByte(byte);
+			}
+			
+			return result;
+		}
+	}
+}

DISPLAYER/com/adobe/air/filesystem/FileMonitor.as

@@ -0,0 +1,245 @@
+/*
+  Copyright (c) 2009, 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.filesystem
+{
+	import flash.filesystem.File;
+	import flash.utils.Timer;
+	import flash.events.TimerEvent;
+	import flash.events.Event;
+	import flash.events.EventDispatcher;
+	import com.adobe.air.filesystem.events.FileMonitorEvent;
+
+	/*
+		Todo:
+		
+		-Cmonitor changes in multiple attributes
+		-add support for monitoring multiple files
+	*/
+	
+	/**
+	* Dispatched when the modified date of the file being modified changes.
+	*
+	* @eventType com.adobe.air.filesystem.events.FileMonitor.CHANGE
+	*/
+	[Event(name="CHANGE", type="com.adobe.air.filesystem.events.FileMonitor")]		
+
+	/**
+	* Dispatched when the file being monitored is moved or deleted. The file 
+	* will be unwatched.
+	*
+	* @eventType com.adobe.air.filesystem.events.FileMonitor.MOVE
+	*/
+	[Event(name="MOVE", type="com.adobe.air.filesystem.events.FileMonitor")]	
+	
+	/**
+	* Dispatched when the file being monitored is created.
+	*
+	* @eventType com.adobe.air.filesystem.events.FileMonitor.CREATE
+	*/
+	[Event(name="CREATE", type="com.adobe.air.filesystem.events.FileMonitor")]			
+	
+	/**
+	* Class that monitors files for changes.
+	*/
+	public class FileMonitor extends EventDispatcher
+	{
+		private var _file:File;
+		private var timer:Timer;
+		public static const DEFAULT_MONITOR_INTERVAL:Number = 1000;
+		private var _interval:Number;
+		private var fileExists:Boolean = false;
+		
+		private var lastModifiedTime:Number;
+		
+		/**
+		 *  Constructor
+		 * 
+		 * 	@parameter file The File that will be monitored for changes.
+		 * 
+		 * 	@param interval How often in milliseconds the file is polled for
+		 * 	change events. Default value is 1000, minimum value is 1000
+		 */ 
+		public function FileMonitor(file:File = null, interval:Number = -1)
+		{
+			this.file = file;
+			
+			if(interval != -1)
+			{
+				if(interval < 1000)
+				{
+					_interval = 1000;
+				}
+				else
+				{
+					_interval = interval;
+				}
+			}
+			else
+			{
+				_interval = DEFAULT_MONITOR_INTERVAL;
+			}
+		}
+	
+		/**
+		 * File being monitored for changes.
+		 * 
+		 * Setting the property will result in unwatch() being called.
+		 */
+		public function get file():File
+		{
+			return _file;
+		}
+		
+		public function set file(file:File):void
+		{			
+			if(timer && timer.running)
+			{
+				unwatch();
+			}
+			
+			_file = file;
+			
+			if(!_file)
+			{
+				fileExists = false;
+				return;
+			}
+
+			//note : this will throw an error if new File() is passed in.
+			fileExists = _file.exists;
+			if(fileExists)
+			{
+				lastModifiedTime = _file.modificationDate.getTime();
+			}	
+
+		}
+		
+		/**
+		 * 	How often the system is polled for Volume change events.
+		 */
+		public function get interval():Number
+		{
+			return _interval;
+		}		
+		
+		/**
+		 * Begins monitoring the specified file for changes.
+		 * 
+		 * Broadcasts Event.CHANGE event when the file's modification date has changed.
+		 */
+		public function watch():void
+		{
+			if(!file)
+			{
+				//should we throw an error?
+				return;
+			}
+			
+			if(timer && timer.running)
+			{
+				return;
+			}
+			
+			//check and see if timer is active. if it is, return
+			if(!timer)
+			{
+				timer = new Timer(_interval);
+				timer.addEventListener(TimerEvent.TIMER, onTimerEvent, false, 0, true);
+			}
+			
+			timer.start();
+		}
+		
+		/**
+		 * Stops watching the specified file for changes.
+		 */
+		public function unwatch():void
+		{
+			if(!timer)
+			{
+				return;
+			}
+			
+			timer.stop();
+			timer.removeEventListener(TimerEvent.TIMER, onTimerEvent);
+		}
+		
+		private function onTimerEvent(e:TimerEvent):void
+		{
+			var outEvent:FileMonitorEvent;
+			
+			if(fileExists != _file.exists)
+			{
+				if(_file.exists)
+				{
+					//file was created
+					outEvent = new FileMonitorEvent(FileMonitorEvent.CREATE);
+					lastModifiedTime = _file.modificationDate.getTime();
+				}
+				else
+				{
+					//file was moved / deleted
+					outEvent = new FileMonitorEvent(FileMonitorEvent.MOVE);
+					unwatch();
+				}
+				fileExists = _file.exists;
+			}
+			else
+			{	
+				if(!_file.exists)
+				{
+					return;
+				}				
+					
+				var modifiedTime:Number = _file.modificationDate.getTime();
+				
+				if(modifiedTime == lastModifiedTime)
+				{
+					return;
+				}
+				
+				lastModifiedTime = modifiedTime;
+				
+				//file modified
+				outEvent = new FileMonitorEvent(FileMonitorEvent.CHANGE);
+			}
+			
+			if(outEvent)
+			{
+				outEvent.file = _file;
+				dispatchEvent(outEvent);
+			}
+
+		}
+	}
+}

DISPLAYER/com/adobe/air/filesystem/FileUtil.as

@@ -0,0 +1,63 @@
+/*
+  Copyright (c) 2009, 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.filesystem
+{
+	import flash.system.Capabilities;
+	import flash.filesystem.File;
+	
+	
+	public class FileUtil
+	{
+		/**
+		 *	@return An Array of Files representing the root directories of the
+		 * 			operating system.
+		 */
+		public static function getRootDirectories():Array
+		{
+			var v:Array = File.getRootDirectories();
+			var os:String = Capabilities.os;
+
+			if(os.indexOf("Mac") > -1)
+			{
+				v = File(v[0]).resolvePath("Volumes").getDirectoryListing();
+			}
+			else if(os.indexOf("Linux") > -1)
+			{
+				//todo: need to impliment Linux
+			}
+			
+			return v;
+		}
+
+	}
+}

DISPLAYER/com/adobe/air/filesystem/VolumeMonitor.as

@@ -0,0 +1,184 @@
+/*
+  Copyright (c) 2009, 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.filesystem
+{
+	import flash.events.EventDispatcher;
+	import flash.utils.Timer;
+	import flash.events.TimerEvent;
+	import flash.filesystem.File;
+	import flash.utils.Dictionary;
+	import com.adobe.air.filesystem.events.FileMonitorEvent;
+	import com.adobe.utils.ArrayUtil;
+
+	/**
+	* Dispatched when a volume is added to the system.
+	*
+	* @eventType com.adobe.air.filesystem.events.FileMonitor.ADD_VOLUME
+	*/
+	[Event(name="ADD_VOLUME", type="com.adobe.air.filesystem.events.FileMonitor")]	
+
+	/**
+	* Dispatched when a volume is removed from the system.
+	*
+	* @eventType com.adobe.air.filesystem.events.FileMonitor.REMOVE_VOLUME
+	*/
+	[Event(name="REMOVE_VOLUME", type="com.adobe.air.filesystem.events.FileMonitor")]	
+
+	/**
+	 * Class that monitors changes to the File volumes attached to the operating
+	 * system.
+	 */ 
+	public class VolumeMonitor extends EventDispatcher
+	{
+		private var timer:Timer;
+		private var _interval:Number;
+		private static const DEFAULT_MONITOR_INTERVAL:Number = 2000;
+		
+		private var volumes:Dictionary;
+		
+		/**
+		 * 	Constructor.
+		 * 
+		 * 	@param interval How often in milliseconds the system is polled for
+		 * 	volume change events. Default value is 2000, minimum value is 1000
+		 */
+		public function VolumeMonitor(interval:Number = -1)
+		{
+			if(interval != -1)
+			{
+				if(interval < 1000)
+				{
+					_interval = 1000;
+				}
+				else
+				{
+					_interval = interval;
+				}
+			}
+			else
+			{
+				_interval = DEFAULT_MONITOR_INTERVAL;
+			}
+		}
+		
+		/**
+		 * 	How often the system is polled for Volume change events.
+		 */
+		public function get interval():Number
+		{
+			return _interval;
+		}
+		
+		/**
+		 * Begins the monitoring of changes to the attached File volumes.
+		 */
+		public function watch():void
+		{
+			if(!timer)
+			{
+				timer = new Timer(_interval);
+				timer.addEventListener(TimerEvent.TIMER, onTimerEvent,false,0, true);
+			}
+			
+			//we reinitialize the hash everytime we start watching
+			volumes = new Dictionary();
+			
+			var v:Array = FileUtil.getRootDirectories();
+			for each(var f:File in v)
+			{
+				//null or undefined
+				if(volumes[f.url] == null)
+				{
+					volumes[f.url] = f;
+				}
+			}			
+			
+			timer.start();
+		}
+		
+		/**
+		 * Stops monitoring for changes to the attached File volumes.
+		 */
+		public function unwatch():void
+		{
+			timer.stop();
+			timer.removeEventListener(TimerEvent.TIMER, onTimerEvent);
+		}
+		
+		private function onTimerEvent(e:TimerEvent):void
+		{
+			var v:Array = FileUtil.getRootDirectories();
+			
+			var outEvent:FileMonitorEvent;
+			var found:Boolean = false;
+			for(var key:String in volumes)
+			{
+				for each(var f:File in v)
+				{
+					//trace("--\n" + key);
+					//trace(f.url);
+					if(f.url == key)
+					{
+						found = true;
+						break;
+					}
+				}
+				
+				if(!found)
+				{
+					outEvent = new FileMonitorEvent(FileMonitorEvent.REMOVE_VOLUME);
+					outEvent.file = volumes[key];
+					dispatchEvent(outEvent);
+					delete volumes[key];
+				}
+				
+				found  = false;
+			}
+			
+			for each(var f2:File in v)
+			{
+				//null or undefined
+				if(volumes[f2.url] == null)
+				{
+					volumes[f2.url] = f2;
+					outEvent = new FileMonitorEvent(FileMonitorEvent.ADD_VOLUME);
+					outEvent.file = f2;
+					
+					dispatchEvent(outEvent);
+				}
+			}
+		}
+		
+
+	}
+}

DISPLAYER/com/adobe/air/filesystem/events/FileMonitorEvent.as

@@ -0,0 +1,61 @@
+/*
+  Copyright (c) 2009, 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.filesystem.events
+{
+	import flash.events.Event;
+	import flash.filesystem.File;
+
+	public class FileMonitorEvent extends Event
+	{
+		public static const CHANGE:String = "onFileChange";
+		public static const MOVE:String = "onFileMove";
+		public static const CREATE:String = "onFileCreate";
+		public static const ADD_VOLUME:String = "onVolumeAdd";
+		public static const REMOVE_VOLUME:String = "onVolumeRemove";
+		
+		public var file:File;
+		public function FileMonitorEvent(type:String, bubbles:Boolean=false, 
+				cancelable:Boolean=false)
+		{
+			super(type, bubbles, cancelable);
+		}
+		
+		public override function clone():Event
+		{
+			var out:FileMonitorEvent = new FileMonitorEvent(type, bubbles, cancelable);
+			out.file = file;
+			
+			return out;
+		}
+	}
+}

DISPLAYER/com/adobe/air/logging/FileTarget.as

@@ -0,0 +1,95 @@
+/*
+  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 flash.filesystem.File;
+	import flash.filesystem.FileMode;
+	import flash.filesystem.FileStream;
+	
+	import mx.core.mx_internal;
+	import mx.logging.targets.LineFormattedTarget;
+	
+	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 + File.lineEnding);
+				fs.close();
+		}	
+		
+		public function clear():void
+		{
+			var fs:FileStream = new FileStream();
+				fs.open(log, FileMode.WRITE);
+				fs.writeUTFBytes("");
+				fs.close();			
+		}
+		
+	}
+}

DISPLAYER/com/adobe/air/net/ResourceCache.as

@@ -0,0 +1,165 @@
+/*
+  Copyright (c) 2009, 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.net
+{
+	import com.adobe.crypto.MD5;
+	import com.adobe.net.DynamicURLLoader;
+	
+	import flash.events.Event;
+	import flash.events.EventDispatcher;
+	import flash.events.IOErrorEvent;
+	import flash.filesystem.File;
+	import flash.filesystem.FileMode;
+	import flash.filesystem.FileStream;
+	import flash.net.URLLoaderDataFormat;
+	import flash.net.URLRequest;
+	import flash.utils.ByteArray;
+	import com.adobe.air.net.events.ResourceCacheEvent;
+
+	//todo: add event metadata
+
+	public class ResourceCache extends EventDispatcher
+	{
+		private var _cacheName:String;
+		//maybe rename to make it clearer it loads data
+		public function ResourceCache(cacheName:String)
+		{
+			_cacheName = cacheName;
+		}
+		
+		public function get cacheName():String
+		{
+			return _cacheName;
+		}
+		
+		private function getStorageDir():File
+		{
+			return File.applicationStorageDirectory.resolvePath(_cacheName);
+		}
+		
+		public function itemExists(key:String):Boolean
+		{
+			return getItemFile(key).exists;
+		}
+		
+		public function clearCache():void
+		{
+			var cacheDir:File = getStorageDir();
+			try
+			{
+				cacheDir.deleteDirectory(true);
+			}
+			catch (e:IOErrorEvent)
+			{
+				// we tried!
+			}
+		}
+		
+		public function getItemFile(key:String):File
+		{
+			var dir:File = getStorageDir();
+			var fName:String = generateKeyHash(key);
+			var file:File = dir.resolvePath(fName);
+			
+			return file;
+		}
+		
+		public function retrieve(url:String):void
+		{
+			
+			var key:String = generateKeyHash(url);
+			var file:File = getItemFile(key);
+			
+			//todo: do we need to check if the dir exists?
+			
+			if(file.exists)
+			{
+				var e:ResourceCacheEvent = new ResourceCacheEvent(ResourceCacheEvent.ITEM_READY);
+					e.key = key;
+					e.file = file;
+					
+				dispatchEvent(e);	
+				return;
+			}
+			
+			
+			var loader:DynamicURLLoader = new DynamicURLLoader();
+				loader.file = file;
+				loader.key = key;
+				
+				loader.addEventListener(Event.COMPLETE, onDataLoad);
+				loader.addEventListener(IOErrorEvent.IO_ERROR, onLoadError);
+				
+				loader.dataFormat = URLLoaderDataFormat.BINARY;
+				
+				loader.load(new URLRequest(url));
+			
+		}
+		
+		private function onLoadError(event:IOErrorEvent):void
+		{
+			trace("onLoadError : could not cache item");
+		}
+		
+		private function onDataLoad(event:Event):void
+		{
+			var loader:DynamicURLLoader = DynamicURLLoader(event.target);
+			
+			var f:File = File(loader.file);
+			var key:String = String(loader.key);
+			
+			var fileStream:FileStream = new FileStream();
+				fileStream.open(f, FileMode.WRITE);
+				fileStream.writeBytes(loader.data as ByteArray);
+				fileStream.close();
+				
+				var g:ResourceCacheEvent = new ResourceCacheEvent(ResourceCacheEvent.ITEM_CACHED);
+					g.key = key;
+					g.file = f;
+					
+				dispatchEvent(g);	
+				
+				var e:ResourceCacheEvent = new ResourceCacheEvent(ResourceCacheEvent.ITEM_READY);
+					e.key = key;
+					e.file = f;
+					
+				dispatchEvent(e);	
+		}
+		
+		
+		private function generateKeyHash(key:String):String
+		{
+			return MD5.hash(key);
+		}
+	}
+}

DISPLAYER/com/adobe/air/net/events/ResourceCacheEvent.as

@@ -0,0 +1,70 @@
+/*
+  Copyright (c) 2009, 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.net.events
+{
+	import flash.events.Event;
+	import flash.filesystem.File;
+
+	public class ResourceCacheEvent extends Event
+	{
+		
+		public static const ITEM_READY:String = "onPathReady";
+		public static const ITEM_CACHED:String = "onItemCached";
+		
+		[Bindable]
+		public var key:String;
+		
+		[Bindable]
+		public var file:File;		
+		
+		public function ResourceCacheEvent(type:String, 
+												bubbles:Boolean=false, 
+												cancelable:Boolean=false)
+		{
+			super(type, bubbles, cancelable);
+		}
+		
+		public override function clone():Event
+		{
+			var out:ResourceCacheEvent = new ResourceCacheEvent(type,
+																bubbles,
+																cancelable);
+																
+			out.key = key;
+			out.file = file;
+			
+			return out;
+		}
+		
+	}
+}

DISPLAYER/com/adobe/crypto/HMAC.as

@@ -0,0 +1,127 @@
+/*
+  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 );
+		}
+		
+	}
+	
+}

DISPLAYER/com/adobe/crypto/MD5.as

@@ -0,0 +1,281 @@
+/*
+  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;	
+	/**
+	 * The MD5 Message-Digest Algorithm
+	 *
+	 * Implementation based on algorithm description at 
+	 * http://www.faqs.org/rfcs/rfc1321.html
+	 */
+	public class MD5 {
+		
+		public static var digest:ByteArray;
+		/**
+		 * Performs the MD5 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 Flash 8.5
+		 * @tiptext
+		 */
+		 
+		public static function hash(s:String) :String{
+			//Convert to byteArray and send through hashBinary function
+			// so as to only have complex code in one location
+			var ba:ByteArray = new ByteArray();
+			ba.writeUTFBytes(s);	
+			return hashBinary(ba);
+		}
+		
+		public static function hashBytes(s:ByteArray) :String{	
+			return hashBinary(s);
+		}
+		
+		/**
+		 * Performs the MD5 hash algorithm on a ByteArray.
+		 *
+		 * @param s The string to hash
+		 * @return A string containing the hash value of s
+		 * @langversion ActionScript 3.0
+		 * @playerversion Flash 8.5
+		 * @tiptext
+		 */	 
+		public static function hashBinary( s:ByteArray ):String {
+			// initialize the md buffers
+			var a:int = 1732584193;
+			var b:int = -271733879;
+			var c:int = -1732584194;
+			var d:int = 271733878;
+			
+			// variables to store previous values
+			var aa:int;
+			var bb:int;
+			var cc:int;
+			var dd:int;
+			
+			// create the blocks from the string and
+			// save the length as a local var to reduce
+			// lookup in the loop below
+			var x:Array = createBlocks( s );
+			var len:int = x.length;
+			
+			// loop over all of the blocks
+			for ( var i:int = 0; i < len; i += 16) {
+				// save previous values
+				aa = a;
+				bb = b;
+				cc = c;
+				dd = d;				
+				
+				// Round 1
+				a = ff( a, b, c, d, x[int(i+ 0)],  7, -680876936 ); 	// 1
+				d = ff( d, a, b, c, x[int(i+ 1)], 12, -389564586 );	// 2
+				c = ff( c, d, a, b, x[int(i+ 2)], 17, 606105819 ); 	// 3
+				b = ff( b, c, d, a, x[int(i+ 3)], 22, -1044525330 );	// 4
+				a = ff( a, b, c, d, x[int(i+ 4)],  7, -176418897 ); 	// 5
+				d = ff( d, a, b, c, x[int(i+ 5)], 12, 1200080426 ); 	// 6
+				c = ff( c, d, a, b, x[int(i+ 6)], 17, -1473231341 );	// 7
+				b = ff( b, c, d, a, x[int(i+ 7)], 22, -45705983 ); 	// 8
+				a = ff( a, b, c, d, x[int(i+ 8)],  7, 1770035416 ); 	// 9
+				d = ff( d, a, b, c, x[int(i+ 9)], 12, -1958414417 );	// 10
+				c = ff( c, d, a, b, x[int(i+10)], 17, -42063 ); 		// 11
+				b = ff( b, c, d, a, x[int(i+11)], 22, -1990404162 );	// 12
+				a = ff( a, b, c, d, x[int(i+12)],  7, 1804603682 ); 	// 13
+				d = ff( d, a, b, c, x[int(i+13)], 12, -40341101 ); 	// 14
+				c = ff( c, d, a, b, x[int(i+14)], 17, -1502002290 );	// 15
+				b = ff( b, c, d, a, x[int(i+15)], 22, 1236535329 ); 	// 16
+				
+				// Round 2
+				a = gg( a, b, c, d, x[int(i+ 1)],  5, -165796510 ); 	// 17
+				d = gg( d, a, b, c, x[int(i+ 6)],  9, -1069501632 );	// 18
+				c = gg( c, d, a, b, x[int(i+11)], 14, 643717713 ); 	// 19
+				b = gg( b, c, d, a, x[int(i+ 0)], 20, -373897302 ); 	// 20
+				a = gg( a, b, c, d, x[int(i+ 5)],  5, -701558691 ); 	// 21
+				d = gg( d, a, b, c, x[int(i+10)],  9, 38016083 ); 	// 22
+				c = gg( c, d, a, b, x[int(i+15)], 14, -660478335 ); 	// 23
+				b = gg( b, c, d, a, x[int(i+ 4)], 20, -405537848 ); 	// 24
+				a = gg( a, b, c, d, x[int(i+ 9)],  5, 568446438 ); 	// 25
+				d = gg( d, a, b, c, x[int(i+14)],  9, -1019803690 );	// 26
+				c = gg( c, d, a, b, x[int(i+ 3)], 14, -187363961 ); 	// 27
+				b = gg( b, c, d, a, x[int(i+ 8)], 20, 1163531501 ); 	// 28
+				a = gg( a, b, c, d, x[int(i+13)],  5, -1444681467 );	// 29
+				d = gg( d, a, b, c, x[int(i+ 2)],  9, -51403784 ); 	// 30
+				c = gg( c, d, a, b, x[int(i+ 7)], 14, 1735328473 ); 	// 31
+				b = gg( b, c, d, a, x[int(i+12)], 20, -1926607734 );	// 32
+				
+				// Round 3
+				a = hh( a, b, c, d, x[int(i+ 5)],  4, -378558 ); 	// 33
+				d = hh( d, a, b, c, x[int(i+ 8)], 11, -2022574463 );	// 34
+				c = hh( c, d, a, b, x[int(i+11)], 16, 1839030562 ); 	// 35
+				b = hh( b, c, d, a, x[int(i+14)], 23, -35309556 ); 	// 36
+				a = hh( a, b, c, d, x[int(i+ 1)],  4, -1530992060 );	// 37
+				d = hh( d, a, b, c, x[int(i+ 4)], 11, 1272893353 ); 	// 38
+				c = hh( c, d, a, b, x[int(i+ 7)], 16, -155497632 ); 	// 39
+				b = hh( b, c, d, a, x[int(i+10)], 23, -1094730640 );	// 40
+				a = hh( a, b, c, d, x[int(i+13)],  4, 681279174 ); 	// 41
+				d = hh( d, a, b, c, x[int(i+ 0)], 11, -358537222 ); 	// 42
+				c = hh( c, d, a, b, x[int(i+ 3)], 16, -722521979 ); 	// 43
+				b = hh( b, c, d, a, x[int(i+ 6)], 23, 76029189 ); 	// 44
+				a = hh( a, b, c, d, x[int(i+ 9)],  4, -640364487 ); 	// 45
+				d = hh( d, a, b, c, x[int(i+12)], 11, -421815835 ); 	// 46
+				c = hh( c, d, a, b, x[int(i+15)], 16, 530742520 ); 	// 47
+				b = hh( b, c, d, a, x[int(i+ 2)], 23, -995338651 ); 	// 48
+				
+				// Round 4
+				a = ii( a, b, c, d, x[int(i+ 0)],  6, -198630844 ); 	// 49
+				d = ii( d, a, b, c, x[int(i+ 7)], 10, 1126891415 ); 	// 50
+				c = ii( c, d, a, b, x[int(i+14)], 15, -1416354905 );	// 51
+				b = ii( b, c, d, a, x[int(i+ 5)], 21, -57434055 ); 	// 52
+				a = ii( a, b, c, d, x[int(i+12)],  6, 1700485571 ); 	// 53
+				d = ii( d, a, b, c, x[int(i+ 3)], 10, -1894986606 );	// 54
+				c = ii( c, d, a, b, x[int(i+10)], 15, -1051523 ); 	// 55
+				b = ii( b, c, d, a, x[int(i+ 1)], 21, -2054922799 );	// 56
+				a = ii( a, b, c, d, x[int(i+ 8)],  6, 1873313359 ); 	// 57
+				d = ii( d, a, b, c, x[int(i+15)], 10, -30611744 ); 	// 58
+				c = ii( c, d, a, b, x[int(i+ 6)], 15, -1560198380 );	// 59
+				b = ii( b, c, d, a, x[int(i+13)], 21, 1309151649 ); 	// 60
+				a = ii( a, b, c, d, x[int(i+ 4)],  6, -145523070 ); 	// 61
+				d = ii( d, a, b, c, x[int(i+11)], 10, -1120210379 );	// 62
+				c = ii( c, d, a, b, x[int(i+ 2)], 15, 718787259 ); 	// 63
+				b = ii( b, c, d, a, x[int(i+ 9)], 21, -343485551 ); 	// 64
+
+				a += aa;
+				b += bb;
+				c += cc;
+				d += dd;
+			}
+			digest = new ByteArray()
+			digest.writeInt(a);
+			digest.writeInt(b);
+			digest.writeInt(c);
+			digest.writeInt(d);
+			digest.position = 0;
+			// Finish up by concatening the buffers with their hex output
+			return IntUtil.toHex( a ) + IntUtil.toHex( b ) + IntUtil.toHex( c ) + IntUtil.toHex( d );
+		}
+		
+		/**
+		 * Auxiliary function f as defined in RFC
+		 */
+		private static function f( x:int, y:int, z:int ):int {
+			return ( x & y ) | ( (~x) & z );
+		}
+		
+		/**
+		 * Auxiliary function g as defined in RFC
+		 */
+		private static function g( x:int, y:int, z:int ):int {
+			return ( x & z ) | ( y & (~z) );
+		}
+		
+		/**
+		 * Auxiliary function h as defined in RFC
+		 */
+		private static function h( x:int, y:int, z:int ):int {
+			return x ^ y ^ z;
+		}
+		
+		/**
+		 * Auxiliary function i as defined in RFC
+		 */
+		private static function i( x:int, y:int, z:int ):int {
+			return y ^ ( x | (~z) );
+		}
+		
+		/**
+		 * A generic transformation function.  The logic of ff, gg, hh, and
+		 * ii are all the same, minus the function used, so pull that logic
+		 * out and simplify the method bodies for the transoformation functions.
+		 */
+		private static function transform( func:Function, a:int, b:int, c:int, d:int, x:int, s:int, t:int):int {
+			var tmp:int = a + int( func( b, c, d ) ) + x + t;
+			return IntUtil.rol( tmp, s ) +  b;
+		}
+		
+		/**
+		 * ff transformation function
+		 */
+		private static function ff ( a:int, b:int, c:int, d:int, x:int, s:int, t:int ):int {
+			return transform( f, a, b, c, d, x, s, t );
+		}
+		
+		/**
+		 * gg transformation function
+		 */
+		private static function gg ( a:int, b:int, c:int, d:int, x:int, s:int, t:int ):int {
+			return transform( g, a, b, c, d, x, s, t );
+		}
+		
+		/**
+		 * hh transformation function
+		 */
+		private static function hh ( a:int, b:int, c:int, d:int, x:int, s:int, t:int ):int {
+			return transform( h, a, b, c, d, x, s, t );
+		}
+		
+		/**
+		 * ii transformation function
+		 */
+		private static function ii ( a:int, b:int, c:int, d:int, x:int, s:int, t:int ):int {
+			return transform( i, a, b, c, d, x, s, t );
+		}
+		
+		/**
+		 * 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 createBlocks( s:ByteArray ):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[ int(i >> 5) ] |= ( s[ i / 8 ] & mask ) << ( i % 32 );
+			}
+			
+			// append padding and length
+			blocks[ int(len >> 5) ] |= 0x80 << ( len % 32 );
+			blocks[ int(( ( ( len + 64 ) >>> 9 ) << 4 ) + 14) ] = len;
+			return blocks;
+		}
+		
+	}
+}

DISPLAYER/com/adobe/crypto/MD5Stream.as

@@ -0,0 +1,402 @@
+/*
+  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;
+
+    /**
+     * Perform MD5 hash of an input stream in chunks. This class is
+     * based on com.adobe.crypto.MD5 and can process data in
+     * chunks. Both block creation and hash computation are done
+     * together for whatever input is available so that the memory
+     * overhead at a time is always fixed. Memory usage is governed by
+     * two parameters: one is the amount of data passed in to update()
+     * and the other is memoryBlockSize. The latter comes into play
+     * only when the memory window exceeds the pre allocated memory
+     * window of flash player. Usage: create an instance, call
+     * update(data) repeatedly for all chunks and finally complete()
+     * which will return the md5 hash.
+     */      
+    public class MD5Stream
+    {
+        private static var mask:int = 0xFF;
+
+        private var arr:Array = [];
+
+        /* running count of length */
+        private var arrLen:int;
+        
+        // initialize the md buffers
+        private var a:int = 1732584193;
+        private var b:int = -271733879;
+        private var c:int = -1732584194;
+        private var d:int = 271733878;
+        
+        // variables to store previous values
+        private var aa:int;
+        private var bb:int;
+        private var cc:int;
+        private var dd:int;
+
+        /* index for data read */
+        private var arrIndexLen:int = 0;
+        /* index for hash computation */
+        private var arrProcessIndex:int = 0;
+        /* index for removing stale arr values */
+        private var cleanIndex:int = 0;
+        
+        /** 
+         * Change this value from the default (16384) in the range of
+         * MBs to actually affect GC as GC allocates in pools of
+         * memory */
+        public var memoryBlockSize:int = 16384;
+        
+        
+        public function MD5Stream()
+        {
+            
+        }
+               
+        
+        /**
+         * Pass in chunks of the input data with update(), call
+         * complete() with an optional chunk which will return the
+         * final hash. Equivalent to the way
+         * java.security.MessageDigest works.
+         *
+         * @param input The optional bytearray chunk which is the final part of the input
+         * @return A string containing the hash value
+         * @langversion ActionScript 3.0
+         * @playerversion Flash 8.5
+         * @tiptext
+         */
+        public function complete(input:ByteArray=null):String
+        {
+            if ( arr.length == 0 )
+            {
+                if ( input == null )
+                {
+                    throw new Error("null input to complete without prior call to update. At least an empty bytearray must be passed.");
+                }		 		
+            }
+            
+            if ( input != null )
+            {
+                readIntoArray(input);
+            }
+
+            //pad, append length
+            padArray(arrLen);
+
+            hashRemainingChunks(false);
+            
+            var res:String = IntUtil.toHex( a ) + IntUtil.toHex( b ) + 
+            				 IntUtil.toHex( c ) + IntUtil.toHex( d );
+            resetFields();
+            
+            return res;
+        }
+
+        /**
+         * Pass in chunks of the input data with update(), call
+         * complete() with an optional chunk which will return the
+         * final hash. Equivalent to the way
+         * java.security.MessageDigest works.
+         *
+         * @param input The bytearray chunk to perform the hash on
+         * @langversion ActionScript 3.0
+         * @playerversion Flash 8.5
+         * @tiptext
+         */        
+        public function update(input:ByteArray):void
+        {
+            readIntoArray(input);
+            hashRemainingChunks();
+        }
+
+        /**
+         * Re-initialize this instance for use to perform hashing on
+         * another input stream. This is called automatically by
+         * complete().
+         *
+         * @langversion ActionScript 3.0
+         * @playerversion Flash 8.5
+         * @tiptext
+         */               
+        public function resetFields():void
+        {
+            //truncate array
+            arr.length = 0;
+            arrLen = 0;
+            
+            // initialize the md buffers
+            a = 1732584193;
+            b = -271733879;
+            c = -1732584194;
+            d = 271733878;
+            
+            // variables to store previous values
+            aa = 0;
+            bb = 0;
+            cc = 0;
+            dd = 0;
+            
+            arrIndexLen = 0;            
+            arrProcessIndex = 0;
+            cleanIndex = 0;
+        }
+        
+        /** read into arr and free up used blocks of arr */
+        private function readIntoArray(input:ByteArray):void
+        {
+            var closestChunkLen:int = input.length * 8;
+            arrLen += closestChunkLen;
+            
+            /* clean up memory. if there are entries in the array that
+             * are already processed and the amount is greater than
+             * memoryBlockSize, create a new array, copy the last
+             * block into it and let the old one get picked up by
+             * GC. */
+            if ( arrProcessIndex - cleanIndex > memoryBlockSize )
+            {
+                var newarr:Array= new Array();
+                
+                /* AS Arrays in sparse arrays. arr[2002] can exist 
+                 * without values for arr[0] - arr[2001] */
+                for ( var j:int = arrProcessIndex; j < arr.length; j++ )
+                {						
+                    newarr[j] = arr[j];
+                }
+                
+                cleanIndex = arrProcessIndex;
+                arr = null;
+                arr = newarr;
+            }
+            
+            for ( var k:int = 0; k < closestChunkLen; k+=8 )
+            {
+                //discard high bytes (convert to uint)
+                arr[ int(arrIndexLen >> 5) ] |= ( input[ k / 8 ] & mask ) << ( arrIndexLen % 32 );
+                arrIndexLen += 8;
+            }
+            
+            
+        }
+        
+        private function hashRemainingChunks(bUpdate:Boolean=true):void
+        {
+            var len:int = arr.length;
+
+            /* leave a 16 word block untouched if we are called from
+             * update. This is because, padArray() can modify the last
+             * block and this modification has to happen before we
+             * compute the hash.  */
+            if ( bUpdate )
+            {
+                len -= 16;
+            }
+
+            /* don't do anything if don't have a 16 word block. */
+            if ( arrProcessIndex >= len || len - arrProcessIndex < 15 )
+            {
+                return;
+            }
+
+            
+            for ( var i:int = arrProcessIndex; i < len ; i += 16, arrProcessIndex += 16) 
+            {            	
+                // save previous values
+                aa = a;
+                bb = b;
+                cc = c;
+                dd = d;                         
+                
+                // Round 1
+                a = ff( a, b, c, d, arr[int(i+ 0)],  7, -680876936 );     // 1
+                d = ff( d, a, b, c, arr[int(i+ 1)], 12, -389564586 );     // 2
+                c = ff( c, d, a, b, arr[int(i+ 2)], 17, 606105819 );      // 3
+                b = ff( b, c, d, a, arr[int(i+ 3)], 22, -1044525330 );    // 4
+                a = ff( a, b, c, d, arr[int(i+ 4)],  7, -176418897 );     // 5
+                d = ff( d, a, b, c, arr[int(i+ 5)], 12, 1200080426 );     // 6
+                c = ff( c, d, a, b, arr[int(i+ 6)], 17, -1473231341 );    // 7
+                b = ff( b, c, d, a, arr[int(i+ 7)], 22, -45705983 );      // 8
+                a = ff( a, b, c, d, arr[int(i+ 8)],  7, 1770035416 );     // 9
+                d = ff( d, a, b, c, arr[int(i+ 9)], 12, -1958414417 );    // 10
+                c = ff( c, d, a, b, arr[int(i+10)], 17, -42063 );                 // 11
+                b = ff( b, c, d, a, arr[int(i+11)], 22, -1990404162 );    // 12
+                a = ff( a, b, c, d, arr[int(i+12)],  7, 1804603682 );     // 13
+                d = ff( d, a, b, c, arr[int(i+13)], 12, -40341101 );      // 14
+                c = ff( c, d, a, b, arr[int(i+14)], 17, -1502002290 );    // 15
+                b = ff( b, c, d, a, arr[int(i+15)], 22, 1236535329 );     // 16
+                
+                // Round 2
+                a = gg( a, b, c, d, arr[int(i+ 1)],  5, -165796510 );     // 17
+                d = gg( d, a, b, c, arr[int(i+ 6)],  9, -1069501632 );    // 18
+                c = gg( c, d, a, b, arr[int(i+11)], 14, 643717713 );      // 19
+                b = gg( b, c, d, a, arr[int(i+ 0)], 20, -373897302 );     // 20
+                a = gg( a, b, c, d, arr[int(i+ 5)],  5, -701558691 );     // 21
+                d = gg( d, a, b, c, arr[int(i+10)],  9, 38016083 );       // 22
+                c = gg( c, d, a, b, arr[int(i+15)], 14, -660478335 );     // 23
+                b = gg( b, c, d, a, arr[int(i+ 4)], 20, -405537848 );     // 24
+                a = gg( a, b, c, d, arr[int(i+ 9)],  5, 568446438 );      // 25
+                d = gg( d, a, b, c, arr[int(i+14)],  9, -1019803690 );    // 26
+                c = gg( c, d, a, b, arr[int(i+ 3)], 14, -187363961 );     // 27
+                b = gg( b, c, d, a, arr[int(i+ 8)], 20, 1163531501 );     // 28
+                a = gg( a, b, c, d, arr[int(i+13)],  5, -1444681467 );    // 29
+                d = gg( d, a, b, c, arr[int(i+ 2)],  9, -51403784 );      // 30
+                c = gg( c, d, a, b, arr[int(i+ 7)], 14, 1735328473 );     // 31
+                b = gg( b, c, d, a, arr[int(i+12)], 20, -1926607734 );    // 32
+                
+                // Round 3
+                a = hh( a, b, c, d, arr[int(i+ 5)],  4, -378558 );        // 33
+                d = hh( d, a, b, c, arr[int(i+ 8)], 11, -2022574463 );    // 34
+                c = hh( c, d, a, b, arr[int(i+11)], 16, 1839030562 );     // 35
+                b = hh( b, c, d, a, arr[int(i+14)], 23, -35309556 );      // 36
+                a = hh( a, b, c, d, arr[int(i+ 1)],  4, -1530992060 );    // 37
+                d = hh( d, a, b, c, arr[int(i+ 4)], 11, 1272893353 );     // 38
+                c = hh( c, d, a, b, arr[int(i+ 7)], 16, -155497632 );     // 39
+                b = hh( b, c, d, a, arr[int(i+10)], 23, -1094730640 );    // 40
+                a = hh( a, b, c, d, arr[int(i+13)],  4, 681279174 );      // 41
+                d = hh( d, a, b, c, arr[int(i+ 0)], 11, -358537222 );     // 42
+                c = hh( c, d, a, b, arr[int(i+ 3)], 16, -722521979 );     // 43
+                b = hh( b, c, d, a, arr[int(i+ 6)], 23, 76029189 );       // 44
+                a = hh( a, b, c, d, arr[int(i+ 9)],  4, -640364487 );     // 45
+                d = hh( d, a, b, c, arr[int(i+12)], 11, -421815835 );     // 46
+                c = hh( c, d, a, b, arr[int(i+15)], 16, 530742520 );      // 47
+                b = hh( b, c, d, a, arr[int(i+ 2)], 23, -995338651 );     // 48
+                
+                // Round 4
+                a = ii( a, b, c, d, arr[int(i+ 0)],  6, -198630844 );     // 49
+                d = ii( d, a, b, c, arr[int(i+ 7)], 10, 1126891415 );     // 50
+                c = ii( c, d, a, b, arr[int(i+14)], 15, -1416354905 );    // 51
+                b = ii( b, c, d, a, arr[int(i+ 5)], 21, -57434055 );      // 52
+                a = ii( a, b, c, d, arr[int(i+12)],  6, 1700485571 );     // 53
+                d = ii( d, a, b, c, arr[int(i+ 3)], 10, -1894986606 );    // 54
+                c = ii( c, d, a, b, arr[int(i+10)], 15, -1051523 );       // 55
+                b = ii( b, c, d, a, arr[int(i+ 1)], 21, -2054922799 );    // 56
+                a = ii( a, b, c, d, arr[int(i+ 8)],  6, 1873313359 );     // 57
+                d = ii( d, a, b, c, arr[int(i+15)], 10, -30611744 );      // 58
+                c = ii( c, d, a, b, arr[int(i+ 6)], 15, -1560198380 );    // 59
+                b = ii( b, c, d, a, arr[int(i+13)], 21, 1309151649 );     // 60
+                a = ii( a, b, c, d, arr[int(i+ 4)],  6, -145523070 );     // 61
+                d = ii( d, a, b, c, arr[int(i+11)], 10, -1120210379 );    // 62
+                c = ii( c, d, a, b, arr[int(i+ 2)], 15, 718787259 );      // 63
+                b = ii( b, c, d, a, arr[int(i+ 9)], 21, -343485551 );     // 64
+                
+                a += aa;
+                b += bb;
+                c += cc;
+                d += dd;
+                
+            }
+            
+        }
+        
+        private function padArray(len:int):void
+        {	 		
+            arr[ int(len >> 5) ] |= 0x80 << ( len % 32 );
+            arr[ int(( ( ( len + 64 ) >>> 9 ) << 4 ) + 14) ] = len;
+            arrLen = arr.length;
+        }  
+        
+        /* Code below same as com.adobe.crypto.MD5 */ 
+        
+        /**
+         * Auxiliary function f as defined in RFC
+         */
+        private static function f( x:int, y:int, z:int ):int {
+            return ( x & y ) | ( (~x) & z );
+        }
+        
+        /**
+         * Auxiliary function g as defined in RFC
+         */
+        private static function g( x:int, y:int, z:int ):int {
+            return ( x & z ) | ( y & (~z) );
+        }
+        
+        /**
+         * Auxiliary function h as defined in RFC
+         */
+        private static function h( x:int, y:int, z:int ):int {
+            return x ^ y ^ z;
+        }
+        
+        /**
+         * Auxiliary function i as defined in RFC
+         */
+        private static function i( x:int, y:int, z:int ):int {
+            return y ^ ( x | (~z) );
+        }
+        
+        /**
+         * A generic transformation function.  The logic of ff, gg, hh, and
+         * ii are all the same, minus the function used, so pull that logic
+         * out and simplify the method bodies for the transoformation functions.
+         */
+        private static function transform( func:Function, a:int, b:int, c:int, d:int, x:int, s:int, t:int):int {
+            var tmp:int = a + int( func( b, c, d ) ) + x + t;
+            return IntUtil.rol( tmp, s ) +  b;
+        }
+        
+        /**
+         * ff transformation function
+         */
+        private static function ff ( a:int, b:int, c:int, d:int, x:int, s:int, t:int ):int {
+            return transform( f, a, b, c, d, x, s, t );
+        }
+        
+        /**
+         * gg transformation function
+         */
+        private static function gg ( a:int, b:int, c:int, d:int, x:int, s:int, t:int ):int {
+            return transform( g, a, b, c, d, x, s, t );
+        }
+        
+        /**
+         * hh transformation function
+         */
+        private static function hh ( a:int, b:int, c:int, d:int, x:int, s:int, t:int ):int {
+            return transform( h, a, b, c, d, x, s, t );
+        }
+        
+        /**
+         * ii transformation function
+         */
+        private static function ii ( a:int, b:int, c:int, d:int, x:int, s:int, t:int ):int {
+            return transform( i, a, b, c, d, x, s, t );
+        }
+        
+    }
+}

DISPLAYER/com/adobe/crypto/SHA1.as

@@ -0,0 +1,289 @@
+/*
+  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 );
+			var temp:int;
+			
+			// 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
+				var t:int;
+				for ( t = 0; t < 20; t++ ) {
+					
+					if ( t < 16 ) {
+						// 6.1.a
+						w[ t ] = blocks[ i + t ];
+					} else {
+						// 6.1.b
+						temp = w[ t - 3 ] ^ w[ t - 8 ] ^ w[ t - 14 ] ^ w[ t - 16 ];
+						w[ t ] = ( temp << 1 ) | ( temp >>> 31 )
+					}
+
+					// 6.1.d
+					temp = ( ( a << 5 ) | ( a >>> 27 ) ) + ( ( b & c ) | ( ~b & d ) ) + e + int( w[ t ] ) + 0x5a827999;
+
+					e = d;
+					d = c;
+					c = ( b << 30 ) | ( b >>> 2 );
+					b = a;
+					a = temp;
+				}
+				for ( ; t < 40; t++ )
+				{
+					// 6.1.b
+					temp = w[ t - 3 ] ^ w[ t - 8 ] ^ w[ t - 14 ] ^ w[ t - 16 ];
+					w[ t ] = ( temp << 1 ) | ( temp >>> 31 )
+
+					// 6.1.d
+					temp = ( ( a << 5 ) | ( a >>> 27 ) ) + ( b ^ c ^ d ) + e + int( w[ t ] ) + 0x6ed9eba1;
+
+					e = d;
+					d = c;
+					c = ( b << 30 ) | ( b >>> 2 );
+					b = a;
+					a = temp;
+				}
+				for ( ; t < 60; t++ )
+				{
+					// 6.1.b
+					temp = w[ t - 3 ] ^ w[ t - 8 ] ^ w[ t - 14 ] ^ w[ t - 16 ];
+					w[ t ] = ( temp << 1 ) | ( temp >>> 31 )
+					
+					// 6.1.d
+					temp = ( ( a << 5 ) | ( a >>> 27 ) ) + ( ( b & c ) | ( b & d ) | ( c & d ) ) + e + int( w[ t ] ) + 0x8f1bbcdc;
+					
+					e = d;
+					d = c;
+					c = ( b << 30 ) | ( b >>> 2 );
+					b = a;
+					a = temp;
+				}
+				for ( ; t < 80; t++ )
+				{
+					// 6.1.b
+					temp = w[ t - 3 ] ^ w[ t - 8 ] ^ w[ t - 14 ] ^ w[ t - 16 ];
+					w[ t ] = ( temp << 1 ) | ( temp >>> 31 )
+
+					// 6.1.d
+					temp = ( ( a << 5 ) | ( a >>> 27 ) ) + ( b ^ c ^ d ) + e + int( w[ t ] ) + 0xca62c1d6;
+
+					e = d;
+					d = c;
+					c = ( b << 30 ) | ( b >>> 2 );
+					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;
+		}
+
+		/**
+		 *  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;
+		}
+		
+	}
+}

DISPLAYER/com/adobe/crypto/SHA224.as

@@ -0,0 +1,257 @@
+/*
+  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;
+		}
+	}
+}

DISPLAYER/com/adobe/crypto/SHA256.as

@@ -0,0 +1,261 @@
+/*
+  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;
+		}
+	}
+}

DISPLAYER/com/adobe/crypto/WSSEUsernameToken.as

@@ -0,0 +1,114 @@
+/*
+  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);
+		}
+	}
+}

DISPLAYER/com/adobe/errors/IllegalStateError.as

@@ -0,0 +1,63 @@
+/*
+  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);
+		}
+	}
+}

DISPLAYER/com/adobe/fileformats/vcard/Address.as

@@ -0,0 +1,47 @@
+/*
+  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);
+		}
+	}
+}

DISPLAYER/com/adobe/fileformats/vcard/Email.as

@@ -0,0 +1,39 @@
+/*
+  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;
+	}
+}

DISPLAYER/com/adobe/fileformats/vcard/Phone.as

@@ -0,0 +1,39 @@
+/*
+  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;
+	}
+}

DISPLAYER/com/adobe/fileformats/vcard/VCard.as

@@ -0,0 +1,54 @@
+/*
+  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();
+		}
+	}
+}

DISPLAYER/com/adobe/fileformats/vcard/VCardParser.as

@@ -0,0 +1,246 @@
+/*
+  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;
+		}
+	}
+}

DISPLAYER/com/adobe/images/BitString.as

@@ -0,0 +1,39 @@
+/*
+  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;
+	}
+}

DISPLAYER/com/adobe/images/JPGEncoder.as

@@ -0,0 +1,648 @@
+/*
+  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.*;
+	import flash.utils.*;
+	
+	/**
+	 * Class that converts BitmapData into a valid JPEG
+	 */		
+	public class JPGEncoder
+	{
+
+		// Static table initialization
+	
+		private var ZigZag:Array = [
+			 0, 1, 5, 6,14,15,27,28,
+			 2, 4, 7,13,16,26,29,42,
+			 3, 8,12,17,25,30,41,43,
+			 9,11,18,24,31,40,44,53,
+			10,19,23,32,39,45,52,54,
+			20,22,33,38,46,51,55,60,
+			21,34,37,47,50,56,59,61,
+			35,36,48,49,57,58,62,63
+		];
+	
+		private var YTable:Array = new Array(64);
+		private var UVTable:Array = new Array(64);
+		private var fdtbl_Y:Array = new Array(64);
+		private var fdtbl_UV:Array = new Array(64);
+	
+		private function initQuantTables(sf:int):void
+		{
+			var i:int;
+			var t:Number;
+			var YQT:Array = [
+				16, 11, 10, 16, 24, 40, 51, 61,
+				12, 12, 14, 19, 26, 58, 60, 55,
+				14, 13, 16, 24, 40, 57, 69, 56,
+				14, 17, 22, 29, 51, 87, 80, 62,
+				18, 22, 37, 56, 68,109,103, 77,
+				24, 35, 55, 64, 81,104,113, 92,
+				49, 64, 78, 87,103,121,120,101,
+				72, 92, 95, 98,112,100,103, 99
+			];
+			for (i = 0; i < 64; i++) {
+				t = Math.floor((YQT[i]*sf+50)/100);
+				if (t < 1) {
+					t = 1;
+				} else if (t > 255) {
+					t = 255;
+				}
+				YTable[ZigZag[i]] = t;
+			}
+			var UVQT:Array = [
+				17, 18, 24, 47, 99, 99, 99, 99,
+				18, 21, 26, 66, 99, 99, 99, 99,
+				24, 26, 56, 99, 99, 99, 99, 99,
+				47, 66, 99, 99, 99, 99, 99, 99,
+				99, 99, 99, 99, 99, 99, 99, 99,
+				99, 99, 99, 99, 99, 99, 99, 99,
+				99, 99, 99, 99, 99, 99, 99, 99,
+				99, 99, 99, 99, 99, 99, 99, 99
+			];
+			for (i = 0; i < 64; i++) {
+				t = Math.floor((UVQT[i]*sf+50)/100);
+				if (t < 1) {
+					t = 1;
+				} else if (t > 255) {
+					t = 255;
+				}
+				UVTable[ZigZag[i]] = t;
+			}
+			var aasf:Array = [
+				1.0, 1.387039845, 1.306562965, 1.175875602,
+				1.0, 0.785694958, 0.541196100, 0.275899379
+			];
+			i = 0;
+			for (var row:int = 0; row < 8; row++)
+			{
+				for (var col:int = 0; col < 8; col++)
+				{
+					fdtbl_Y[i]  = (1.0 / (YTable [ZigZag[i]] * aasf[row] * aasf[col] * 8.0));
+					fdtbl_UV[i] = (1.0 / (UVTable[ZigZag[i]] * aasf[row] * aasf[col] * 8.0));
+					i++;
+				}
+			}
+		}
+	
+		private var YDC_HT:Array;
+		private var UVDC_HT:Array;
+		private var YAC_HT:Array;
+		private var UVAC_HT:Array;
+	
+		private function computeHuffmanTbl(nrcodes:Array, std_table:Array):Array
+		{
+			var codevalue:int = 0;
+			var pos_in_table:int = 0;
+			var HT:Array = new Array();
+			for (var k:int=1; k<=16; k++) {
+				for (var j:int=1; j<=nrcodes[k]; j++) {
+					HT[std_table[pos_in_table]] = new BitString();
+					HT[std_table[pos_in_table]].val = codevalue;
+					HT[std_table[pos_in_table]].len = k;
+					pos_in_table++;
+					codevalue++;
+				}
+				codevalue*=2;
+			}
+			return HT;
+		}
+	
+		private var std_dc_luminance_nrcodes:Array = [0,0,1,5,1,1,1,1,1,1,0,0,0,0,0,0,0];
+		private var std_dc_luminance_values:Array = [0,1,2,3,4,5,6,7,8,9,10,11];
+		private var std_ac_luminance_nrcodes:Array = [0,0,2,1,3,3,2,4,3,5,5,4,4,0,0,1,0x7d];
+		private var std_ac_luminance_values:Array = [
+			0x01,0x02,0x03,0x00,0x04,0x11,0x05,0x12,
+			0x21,0x31,0x41,0x06,0x13,0x51,0x61,0x07,
+			0x22,0x71,0x14,0x32,0x81,0x91,0xa1,0x08,
+			0x23,0x42,0xb1,0xc1,0x15,0x52,0xd1,0xf0,
+			0x24,0x33,0x62,0x72,0x82,0x09,0x0a,0x16,
+			0x17,0x18,0x19,0x1a,0x25,0x26,0x27,0x28,
+			0x29,0x2a,0x34,0x35,0x36,0x37,0x38,0x39,
+			0x3a,0x43,0x44,0x45,0x46,0x47,0x48,0x49,
+			0x4a,0x53,0x54,0x55,0x56,0x57,0x58,0x59,
+			0x5a,0x63,0x64,0x65,0x66,0x67,0x68,0x69,
+			0x6a,0x73,0x74,0x75,0x76,0x77,0x78,0x79,
+			0x7a,0x83,0x84,0x85,0x86,0x87,0x88,0x89,
+			0x8a,0x92,0x93,0x94,0x95,0x96,0x97,0x98,
+			0x99,0x9a,0xa2,0xa3,0xa4,0xa5,0xa6,0xa7,
+			0xa8,0xa9,0xaa,0xb2,0xb3,0xb4,0xb5,0xb6,
+			0xb7,0xb8,0xb9,0xba,0xc2,0xc3,0xc4,0xc5,
+			0xc6,0xc7,0xc8,0xc9,0xca,0xd2,0xd3,0xd4,
+			0xd5,0xd6,0xd7,0xd8,0xd9,0xda,0xe1,0xe2,
+			0xe3,0xe4,0xe5,0xe6,0xe7,0xe8,0xe9,0xea,
+			0xf1,0xf2,0xf3,0xf4,0xf5,0xf6,0xf7,0xf8,
+			0xf9,0xfa
+		];
+	
+		private var std_dc_chrominance_nrcodes:Array = [0,0,3,1,1,1,1,1,1,1,1,1,0,0,0,0,0];
+		private var std_dc_chrominance_values:Array = [0,1,2,3,4,5,6,7,8,9,10,11];
+		private var std_ac_chrominance_nrcodes:Array = [0,0,2,1,2,4,4,3,4,7,5,4,4,0,1,2,0x77];
+		private var std_ac_chrominance_values:Array = [
+			0x00,0x01,0x02,0x03,0x11,0x04,0x05,0x21,
+			0x31,0x06,0x12,0x41,0x51,0x07,0x61,0x71,
+			0x13,0x22,0x32,0x81,0x08,0x14,0x42,0x91,
+			0xa1,0xb1,0xc1,0x09,0x23,0x33,0x52,0xf0,
+			0x15,0x62,0x72,0xd1,0x0a,0x16,0x24,0x34,
+			0xe1,0x25,0xf1,0x17,0x18,0x19,0x1a,0x26,
+			0x27,0x28,0x29,0x2a,0x35,0x36,0x37,0x38,
+			0x39,0x3a,0x43,0x44,0x45,0x46,0x47,0x48,
+			0x49,0x4a,0x53,0x54,0x55,0x56,0x57,0x58,
+			0x59,0x5a,0x63,0x64,0x65,0x66,0x67,0x68,
+			0x69,0x6a,0x73,0x74,0x75,0x76,0x77,0x78,
+			0x79,0x7a,0x82,0x83,0x84,0x85,0x86,0x87,
+			0x88,0x89,0x8a,0x92,0x93,0x94,0x95,0x96,
+			0x97,0x98,0x99,0x9a,0xa2,0xa3,0xa4,0xa5,
+			0xa6,0xa7,0xa8,0xa9,0xaa,0xb2,0xb3,0xb4,
+			0xb5,0xb6,0xb7,0xb8,0xb9,0xba,0xc2,0xc3,
+			0xc4,0xc5,0xc6,0xc7,0xc8,0xc9,0xca,0xd2,
+			0xd3,0xd4,0xd5,0xd6,0xd7,0xd8,0xd9,0xda,
+			0xe2,0xe3,0xe4,0xe5,0xe6,0xe7,0xe8,0xe9,
+			0xea,0xf2,0xf3,0xf4,0xf5,0xf6,0xf7,0xf8,
+			0xf9,0xfa
+		];
+	
+		private function initHuffmanTbl():void
+		{
+			YDC_HT = computeHuffmanTbl(std_dc_luminance_nrcodes,std_dc_luminance_values);
+			UVDC_HT = computeHuffmanTbl(std_dc_chrominance_nrcodes,std_dc_chrominance_values);
+			YAC_HT = computeHuffmanTbl(std_ac_luminance_nrcodes,std_ac_luminance_values);
+			UVAC_HT = computeHuffmanTbl(std_ac_chrominance_nrcodes,std_ac_chrominance_values);
+		}
+	
+		private var bitcode:Array = new Array(65535);
+		private var category:Array = new Array(65535);
+	
+		private function initCategoryNumber():void
+		{
+			var nrlower:int = 1;
+			var nrupper:int = 2;
+			var nr:int;
+			for (var cat:int=1; cat<=15; cat++) {
+				//Positive numbers
+				for (nr=nrlower; nr<nrupper; nr++) {
+					category[32767+nr] = cat;
+					bitcode[32767+nr] = new BitString();
+					bitcode[32767+nr].len = cat;
+					bitcode[32767+nr].val = nr;
+				}
+				//Negative numbers
+				for (nr=-(nrupper-1); nr<=-nrlower; nr++) {
+					category[32767+nr] = cat;
+					bitcode[32767+nr] = new BitString();
+					bitcode[32767+nr].len = cat;
+					bitcode[32767+nr].val = nrupper-1+nr;
+				}
+				nrlower <<= 1;
+				nrupper <<= 1;
+			}
+		}
+	
+		// IO functions
+	
+		private var byteout:ByteArray;
+		private var bytenew:int = 0;
+		private var bytepos:int = 7;
+	
+		private function writeBits(bs:BitString):void
+		{
+			var value:int = bs.val;
+			var posval:int = bs.len-1;
+			while ( posval >= 0 ) {
+				if (value & uint(1 << posval) ) {
+					bytenew |= uint(1 << bytepos);
+				}
+				posval--;
+				bytepos--;
+				if (bytepos < 0) {
+					if (bytenew == 0xFF) {
+						writeByte(0xFF);
+						writeByte(0);
+					}
+					else {
+						writeByte(bytenew);
+					}
+					bytepos=7;
+					bytenew=0;
+				}
+			}
+		}
+	
+		private function writeByte(value:int):void
+		{
+			byteout.writeByte(value);
+		}
+	
+		private function writeWord(value:int):void
+		{
+			writeByte((value>>8)&0xFF);
+			writeByte((value   )&0xFF);
+		}
+	
+		// DCT & quantization core
+	
+		private function fDCTQuant(data:Array, fdtbl:Array):Array
+		{
+			var tmp0:Number, tmp1:Number, tmp2:Number, tmp3:Number, tmp4:Number, tmp5:Number, tmp6:Number, tmp7:Number;
+			var tmp10:Number, tmp11:Number, tmp12:Number, tmp13:Number;
+			var z1:Number, z2:Number, z3:Number, z4:Number, z5:Number, z11:Number, z13:Number;
+			var i:int;
+			/* Pass 1: process rows. */
+			var dataOff:int=0;
+			for (i=0; i<8; i++) {
+				tmp0 = data[dataOff+0] + data[dataOff+7];
+				tmp7 = data[dataOff+0] - data[dataOff+7];
+				tmp1 = data[dataOff+1] + data[dataOff+6];
+				tmp6 = data[dataOff+1] - data[dataOff+6];
+				tmp2 = data[dataOff+2] + data[dataOff+5];
+				tmp5 = data[dataOff+2] - data[dataOff+5];
+				tmp3 = data[dataOff+3] + data[dataOff+4];
+				tmp4 = data[dataOff+3] - data[dataOff+4];
+	
+				/* Even part */
+				tmp10 = tmp0 + tmp3;	/* phase 2 */
+				tmp13 = tmp0 - tmp3;
+				tmp11 = tmp1 + tmp2;
+				tmp12 = tmp1 - tmp2;
+	
+				data[dataOff+0] = tmp10 + tmp11; /* phase 3 */
+				data[dataOff+4] = tmp10 - tmp11;
+	
+				z1 = (tmp12 + tmp13) * 0.707106781; /* c4 */
+				data[dataOff+2] = tmp13 + z1; /* phase 5 */
+				data[dataOff+6] = tmp13 - z1;
+	
+				/* Odd part */
+				tmp10 = tmp4 + tmp5; /* phase 2 */
+				tmp11 = tmp5 + tmp6;
+				tmp12 = tmp6 + tmp7;
+	
+				/* The rotator is modified from fig 4-8 to avoid extra negations. */
+				z5 = (tmp10 - tmp12) * 0.382683433; /* c6 */
+				z2 = 0.541196100 * tmp10 + z5; /* c2-c6 */
+				z4 = 1.306562965 * tmp12 + z5; /* c2+c6 */
+				z3 = tmp11 * 0.707106781; /* c4 */
+	
+				z11 = tmp7 + z3;	/* phase 5 */
+				z13 = tmp7 - z3;
+	
+				data[dataOff+5] = z13 + z2;	/* phase 6 */
+				data[dataOff+3] = z13 - z2;
+				data[dataOff+1] = z11 + z4;
+				data[dataOff+7] = z11 - z4;
+	
+				dataOff += 8; /* advance pointer to next row */
+			}
+	
+			/* Pass 2: process columns. */
+			dataOff = 0;
+			for (i=0; i<8; i++) {
+				tmp0 = data[dataOff+ 0] + data[dataOff+56];
+				tmp7 = data[dataOff+ 0] - data[dataOff+56];
+				tmp1 = data[dataOff+ 8] + data[dataOff+48];
+				tmp6 = data[dataOff+ 8] - data[dataOff+48];
+				tmp2 = data[dataOff+16] + data[dataOff+40];
+				tmp5 = data[dataOff+16] - data[dataOff+40];
+				tmp3 = data[dataOff+24] + data[dataOff+32];
+				tmp4 = data[dataOff+24] - data[dataOff+32];
+	
+				/* Even part */
+				tmp10 = tmp0 + tmp3;	/* phase 2 */
+				tmp13 = tmp0 - tmp3;
+				tmp11 = tmp1 + tmp2;
+				tmp12 = tmp1 - tmp2;
+	
+				data[dataOff+ 0] = tmp10 + tmp11; /* phase 3 */
+				data[dataOff+32] = tmp10 - tmp11;
+	
+				z1 = (tmp12 + tmp13) * 0.707106781; /* c4 */
+				data[dataOff+16] = tmp13 + z1; /* phase 5 */
+				data[dataOff+48] = tmp13 - z1;
+	
+				/* Odd part */
+				tmp10 = tmp4 + tmp5; /* phase 2 */
+				tmp11 = tmp5 + tmp6;
+				tmp12 = tmp6 + tmp7;
+	
+				/* The rotator is modified from fig 4-8 to avoid extra negations. */
+				z5 = (tmp10 - tmp12) * 0.382683433; /* c6 */
+				z2 = 0.541196100 * tmp10 + z5; /* c2-c6 */
+				z4 = 1.306562965 * tmp12 + z5; /* c2+c6 */
+				z3 = tmp11 * 0.707106781; /* c4 */
+	
+				z11 = tmp7 + z3;	/* phase 5 */
+				z13 = tmp7 - z3;
+	
+				data[dataOff+40] = z13 + z2; /* phase 6 */
+				data[dataOff+24] = z13 - z2;
+				data[dataOff+ 8] = z11 + z4;
+				data[dataOff+56] = z11 - z4;
+	
+				dataOff++; /* advance pointer to next column */
+			}
+	
+			// Quantize/descale the coefficients
+			for (i=0; i<64; i++) {
+				// Apply the quantization and scaling factor & Round to nearest integer
+				data[i] = Math.round((data[i]*fdtbl[i]));
+			}
+			return data;
+		}
+	
+		// Chunk writing
+	
+		private function writeAPP0():void
+		{
+			writeWord(0xFFE0); // marker
+			writeWord(16); // length
+			writeByte(0x4A); // J
+			writeByte(0x46); // F
+			writeByte(0x49); // I
+			writeByte(0x46); // F
+			writeByte(0); // = "JFIF",'\0'
+			writeByte(1); // versionhi
+			writeByte(1); // versionlo
+			writeByte(0); // xyunits
+			writeWord(1); // xdensity
+			writeWord(1); // ydensity
+			writeByte(0); // thumbnwidth
+			writeByte(0); // thumbnheight
+		}
+	
+		private function writeSOF0(width:int, height:int):void
+		{
+			writeWord(0xFFC0); // marker
+			writeWord(17);   // length, truecolor YUV JPG
+			writeByte(8);    // precision
+			writeWord(height);
+			writeWord(width);
+			writeByte(3);    // nrofcomponents
+			writeByte(1);    // IdY
+			writeByte(0x11); // HVY
+			writeByte(0);    // QTY
+			writeByte(2);    // IdU
+			writeByte(0x11); // HVU
+			writeByte(1);    // QTU
+			writeByte(3);    // IdV
+			writeByte(0x11); // HVV
+			writeByte(1);    // QTV
+		}
+	
+		private function writeDQT():void
+		{
+			writeWord(0xFFDB); // marker
+			writeWord(132);	   // length
+			writeByte(0);
+			var i:int;
+			for (i=0; i<64; i++) {
+				writeByte(YTable[i]);
+			}
+			writeByte(1);
+			for (i=0; i<64; i++) {
+				writeByte(UVTable[i]);
+			}
+		}
+	
+		private function writeDHT():void
+		{
+			writeWord(0xFFC4); // marker
+			writeWord(0x01A2); // length
+			var i:int;
+	
+			writeByte(0); // HTYDCinfo
+			for (i=0; i<16; i++) {
+				writeByte(std_dc_luminance_nrcodes[i+1]);
+			}
+			for (i=0; i<=11; i++) {
+				writeByte(std_dc_luminance_values[i]);
+			}
+	
+			writeByte(0x10); // HTYACinfo
+			for (i=0; i<16; i++) {
+				writeByte(std_ac_luminance_nrcodes[i+1]);
+			}
+			for (i=0; i<=161; i++) {
+				writeByte(std_ac_luminance_values[i]);
+			}
+	
+			writeByte(1); // HTUDCinfo
+			for (i=0; i<16; i++) {
+				writeByte(std_dc_chrominance_nrcodes[i+1]);
+			}
+			for (i=0; i<=11; i++) {
+				writeByte(std_dc_chrominance_values[i]);
+			}
+	
+			writeByte(0x11); // HTUACinfo
+			for (i=0; i<16; i++) {
+				writeByte(std_ac_chrominance_nrcodes[i+1]);
+			}
+			for (i=0; i<=161; i++) {
+				writeByte(std_ac_chrominance_values[i]);
+			}
+		}
+	
+		private function writeSOS():void
+		{
+			writeWord(0xFFDA); // marker
+			writeWord(12); // length
+			writeByte(3); // nrofcomponents
+			writeByte(1); // IdY
+			writeByte(0); // HTY
+			writeByte(2); // IdU
+			writeByte(0x11); // HTU
+			writeByte(3); // IdV
+			writeByte(0x11); // HTV
+			writeByte(0); // Ss
+			writeByte(0x3f); // Se
+			writeByte(0); // Bf
+		}
+	
+		// Core processing
+		private var DU:Array = new Array(64);
+	
+		private function processDU(CDU:Array, fdtbl:Array, DC:Number, HTDC:Array, HTAC:Array):Number
+		{
+			var EOB:BitString = HTAC[0x00];
+			var M16zeroes:BitString = HTAC[0xF0];
+			var i:int;
+	
+			var DU_DCT:Array = fDCTQuant(CDU, fdtbl);
+			//ZigZag reorder
+			for (i=0;i<64;i++) {
+				DU[ZigZag[i]]=DU_DCT[i];
+			}
+			var Diff:int = DU[0] - DC; DC = DU[0];
+			//Encode DC
+			if (Diff==0) {
+				writeBits(HTDC[0]); // Diff might be 0
+			} else {
+				writeBits(HTDC[category[32767+Diff]]);
+				writeBits(bitcode[32767+Diff]);
+			}
+			//Encode ACs
+			var end0pos:int = 63;
+			for (; (end0pos>0)&&(DU[end0pos]==0); end0pos--) {
+			};
+			//end0pos = first element in reverse order !=0
+			if ( end0pos == 0) {
+				writeBits(EOB);
+				return DC;
+			}
+			i = 1;
+			while ( i <= end0pos ) {
+				var startpos:int = i;
+				for (; (DU[i]==0) && (i<=end0pos); i++) {
+				}
+				var nrzeroes:int = i-startpos;
+				if ( nrzeroes >= 16 ) {
+					for (var nrmarker:int=1; nrmarker <= nrzeroes/16; nrmarker++) {
+						writeBits(M16zeroes);
+					}
+					nrzeroes = int(nrzeroes&0xF);
+				}
+				writeBits(HTAC[nrzeroes*16+category[32767+DU[i]]]);
+				writeBits(bitcode[32767+DU[i]]);
+				i++;
+			}
+			if ( end0pos != 63 ) {
+				writeBits(EOB);
+			}
+			return DC;
+		}
+	
+		private var YDU:Array = new Array(64);
+		private var UDU:Array = new Array(64);
+		private var VDU:Array = new Array(64);
+	
+		private function RGB2YUV(img:BitmapData, xpos:int, ypos:int):void
+		{
+			var pos:int=0;
+			for (var y:int=0; y<8; y++) {
+				for (var x:int=0; x<8; x++) {
+					var P:uint = img.getPixel32(xpos+x,ypos+y);
+					var R:Number = Number((P>>16)&0xFF);
+					var G:Number = Number((P>> 8)&0xFF);
+					var B:Number = Number((P    )&0xFF);
+					YDU[pos]=((( 0.29900)*R+( 0.58700)*G+( 0.11400)*B))-128;
+					UDU[pos]=(((-0.16874)*R+(-0.33126)*G+( 0.50000)*B));
+					VDU[pos]=((( 0.50000)*R+(-0.41869)*G+(-0.08131)*B));
+					pos++;
+				}
+			}
+		}
+	
+		/**
+		 * Constructor for JPEGEncoder class
+		 *
+		 * @param quality The quality level between 1 and 100 that detrmines the
+		 * level of compression used in the generated JPEG
+		 * @langversion ActionScript 3.0
+		 * @playerversion Flash 9.0
+		 * @tiptext
+		 */		
+		public function JPGEncoder(quality:Number = 50)
+		{
+			if (quality <= 0) {
+				quality = 1;
+			}
+			if (quality > 100) {
+				quality = 100;
+			}
+			var sf:int = 0;
+			if (quality < 50) {
+				sf = int(5000 / quality);
+			} else {
+				sf = int(200 - quality*2);
+			}
+			// Create tables
+			initHuffmanTbl();
+			initCategoryNumber();
+			initQuantTables(sf);
+		}
+	
+		/**
+		 * Created a JPEG image from the specified BitmapData
+		 *
+		 * @param image The BitmapData that will be converted into the JPEG format.
+		 * @return a ByteArray representing the JPEG encoded image data.
+		 * @langversion ActionScript 3.0
+		 * @playerversion Flash 9.0
+		 * @tiptext
+		 */	
+		public function encode(image:BitmapData):ByteArray
+		{
+			// Initialize bit writer
+			byteout = new ByteArray();
+			bytenew=0;
+			bytepos=7;
+	
+			// Add JPEG headers
+			writeWord(0xFFD8); // SOI
+			writeAPP0();
+			writeDQT();
+			writeSOF0(image.width,image.height);
+			writeDHT();
+			writeSOS();
+
+	
+			// Encode 8x8 macroblocks
+			var DCY:Number=0;
+			var DCU:Number=0;
+			var DCV:Number=0;
+			bytenew=0;
+			bytepos=7;
+			for (var ypos:int=0; ypos<image.height; ypos+=8) {
+				for (var xpos:int=0; xpos<image.width; xpos+=8) {
+					RGB2YUV(image, xpos, ypos);
+					DCY = processDU(YDU, fdtbl_Y, DCY, YDC_HT, YAC_HT);
+					DCU = processDU(UDU, fdtbl_UV, DCU, UVDC_HT, UVAC_HT);
+					DCV = processDU(VDU, fdtbl_UV, DCV, UVDC_HT, UVAC_HT);
+				}
+			}
+	
+			// Do the bit alignment of the EOI marker
+			if ( bytepos >= 0 ) {
+				var fillbits:BitString = new BitString();
+				fillbits.len = bytepos+1;
+				fillbits.val = (1<<(bytepos+1))-1;
+				writeBits(fillbits);
+			}
+	
+			writeWord(0xFFD9); //EOI
+			return byteout;
+		}
+	}
+}

DISPLAYER/com/adobe/images/PNGEncoder.as

@@ -0,0 +1,141 @@
+/*
+  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);
+	    }
+	}
+}

DISPLAYER/com/adobe/net/DynamicURLLoader.as

@@ -0,0 +1,55 @@
+/*
+  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();
+		}
+	}
+}

DISPLAYER/com/adobe/net/IURIResolver.as

@@ -0,0 +1,76 @@
+/*
+  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.</p>
+	 * 
+	 * @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;
+	}
+}

DISPLAYER/com/adobe/net/MimeTypeMap.as

@@ -0,0 +1,200 @@
+/*
+  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/mp4","f4a"],
+			["audio/mp4","f4b"],
+			["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/mp4","f4v"],
+			["video/mp4","f4p"],			
+			["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);
+		}
+	}
+}

DISPLAYER/com/adobe/net/URI.as

@@ -0,0 +1,2466 @@
+/*
+  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 functions and utilities for working with URI's
+	 * (Universal Resource Identifiers).  For technical description of the
+	 * URI syntax, please see RFC 3986 at http://www.ietf.org/rfc/rfc3986.txt
+	 * or do a web search for "rfc 3986".
+	 * 
+	 * <p>The most important aspect of URI's to understand is that URI's
+	 * and URL's are not strings.  URI's are complex data structures that
+	 * encapsulate many pieces of information.  The string version of a
+	 * URI is the serialized representation of that data structure.  This
+	 * string serialization is used to provide a human readable
+	 * representation and a means to transport the data over the network
+	 * where it can then be parsed back into its' component parts.</p>
+	 * 
+	 * <p>URI's fall into one of three categories:
+	 * <ul>
+	 *  <li>&lt;scheme&gt;:&lt;scheme-specific-part&gt;#&lt;fragment&gt;		(non-hierarchical)</li>
+	 *  <li>&lt;scheme&gt;:&lt;authority&gt;&lt;path&gt;?&lt;query&gt;#&lt;fragment&gt;	(hierarchical)</li>
+	 *  <li>&lt;path&gt;?&lt;query&gt;#&lt;fragment&gt;						(relative hierarchical)</li>
+	 * </ul></p>
+	 * 
+	 * <p>The query and fragment parts are optional.</p>
+	 * 
+	 * <p>This class supports both non-hierarchical and hierarchical URI's</p>
+	 * 
+	 * <p>This class is intended to be used "as-is" for the vast majority
+	 * of common URI's.  However, if your application requires a custom
+	 * URI syntax (e.g. custom query syntax or special handling of
+	 * non-hierarchical URI's), this class can be fully subclassed.  If you
+	 * intended to subclass URI, please see the source code for complete
+	 * documation on protected members and protected fuctions.</p>
+	 * 
+	 * @langversion ActionScript 3.0
+	 * @playerversion Flash 9.0 
+	 */
+	public class URI
+	{	
+		// Here we define which characters must be escaped for each
+		// URI part.  The characters that must be escaped for each
+		// part differ depending on what would cause ambiguous parsing.
+		// RFC 3986 sec. 2.4 states that characters should only be
+		// encoded when they would conflict with subcomponent delimiters.
+		// We don't want to over-do the escaping.  We only want to escape
+		// the minimum needed to prevent parsing problems.
+		
+		// space and % must be escaped in all cases.  '%' is the delimiter
+		// for escaped characters.
+		public static const URImustEscape:String =	" %";
+		
+		// Baseline of what characters must be escaped
+		public static const URIbaselineEscape:String = URImustEscape + ":?#/@";
+		
+		// Characters that must be escaped in the part part.
+		public static const URIpathEscape:String = URImustEscape + "?#";
+		
+		// Characters that must be escaped in the query part, if setting
+		// the query as a whole string.  If the query is set by
+		// name/value, URIqueryPartEscape is used instead.
+		public static const URIqueryEscape:String = URImustEscape + "#";
+		
+		// This is what each name/value pair must escape "&=" as well
+		// so they don't conflict with the "param=value&param2=value2"
+		// syntax.
+		public static const URIqueryPartEscape:String = URImustEscape + "#&=";
+		
+		// Non-hierarchical URI's can have query and fragment parts, but
+		// we also want to prevent '/' otherwise it might end up looking
+		// like a hierarchical URI to the parser.
+		public static const URInonHierEscape:String = 	URImustEscape + "?#/";
+		
+		// Baseline uninitialized setting for the URI scheme.
+		public static const UNKNOWN_SCHEME:String = "unknown";
+		
+		// The following bitmaps are used for performance enhanced
+		// character escaping.
+		
+		// Baseline characters that need to be escaped.  Many parts use
+		// this.
+		protected static const URIbaselineExcludedBitmap:URIEncodingBitmap =
+			new URIEncodingBitmap(URIbaselineEscape);
+		
+		// Scheme escaping bitmap
+		protected static const URIschemeExcludedBitmap:URIEncodingBitmap = 
+			URIbaselineExcludedBitmap;
+		
+		// User/pass escaping bitmap
+		protected static const URIuserpassExcludedBitmap:URIEncodingBitmap =
+			URIbaselineExcludedBitmap;
+		
+		// Authority escaping bitmap
+		protected static const URIauthorityExcludedBitmap:URIEncodingBitmap =
+			URIbaselineExcludedBitmap;
+			
+		// Port escaping bitmap
+		protected static const URIportExludedBitmap:URIEncodingBitmap = 
+			URIbaselineExcludedBitmap;
+		
+		// Path escaping bitmap
+		protected static const URIpathExcludedBitmap:URIEncodingBitmap =
+		 	new URIEncodingBitmap(URIpathEscape);
+			
+		// Query (whole) escaping bitmap
+		protected static const URIqueryExcludedBitmap:URIEncodingBitmap =
+			new URIEncodingBitmap(URIqueryEscape);
+			
+		// Query (individual parts) escaping bitmap
+		protected static const URIqueryPartExcludedBitmap:URIEncodingBitmap =
+			new URIEncodingBitmap(URIqueryPartEscape);
+			
+		// Fragments are the last part in the URI.  They only need to
+		// escape space, '#', and '%'.  Turns out that is what query
+		// uses too.
+		protected static const URIfragmentExcludedBitmap:URIEncodingBitmap =
+			URIqueryExcludedBitmap;
+			
+		// Characters that need to be escaped in the non-hierarchical part
+		protected static const URInonHierexcludedBitmap:URIEncodingBitmap =
+			new URIEncodingBitmap(URInonHierEscape);
+			
+		// Values used by getRelation()
+		public static const NOT_RELATED:int = 0;
+		public static const CHILD:int = 1;
+		public static const EQUAL:int = 2;
+		public static const PARENT:int = 3;
+
+		//-------------------------------------------------------------------
+		// protected class members
+		//-------------------------------------------------------------------
+		protected var _valid:Boolean = false;
+		protected var _relative:Boolean = false;
+		protected var _scheme:String = "";
+		protected var _authority:String = "";
+		protected var _username:String = "";
+		protected var _password:String = "";
+		protected var _port:String = "";
+		protected var _path:String = "";
+		protected var _query:String = "";
+		protected var _fragment:String = "";
+		protected var _nonHierarchical:String = "";
+		protected static var _resolver:IURIResolver = null;
+
+
+		/**
+		 *  URI Constructor.  If no string is given, this will initialize
+		 *  this URI object to a blank URI.
+		 */
+		public function URI(uri:String = null) : void	
+		{
+			if (uri == null)
+				initialize();
+			else
+				constructURI(uri);
+		}
+
+		
+		/**
+		 * @private
+		 * Method that loads the URI from the given string.
+		 */
+		protected function constructURI(uri:String) : Boolean
+		{
+			if (!parseURI(uri))
+				_valid = false;
+				
+			return isValid();
+		}
+		
+		
+		/**
+		 * @private Private initializiation.
+		 */
+		protected function initialize() : void
+		{
+			_valid = false;
+			_relative = false;
+		
+			_scheme = UNKNOWN_SCHEME;
+			_authority = "";
+			_username = "";
+			_password = "";
+			_port = "";
+			_path = "";
+			_query = "";
+			_fragment = "";
+		
+			_nonHierarchical = "";
+		}	
+		
+		/**
+		 * @private Accessor to explicitly set/get the hierarchical
+		 * state of the URI.
+		 */
+		protected function set hierState(state:Boolean) : void
+		{
+			if (state)
+			{
+				// Clear the non-hierarchical data
+				_nonHierarchical = "";
+		
+				// Also set the state vars while we are at it
+				if (_scheme == "" || _scheme == UNKNOWN_SCHEME)
+					_relative = true;
+				else
+					_relative = false;
+		
+				if (_authority.length == 0 && _path.length == 0)
+					_valid = false;
+				else
+					_valid = true;
+			}
+			else
+			{
+				// Clear the hierarchical data
+				_authority = "";
+				_username = "";
+				_password = "";
+				_port = "";
+				_path = "";
+		
+				_relative = false;
+		
+				if (_scheme == "" || _scheme == UNKNOWN_SCHEME)
+					_valid = false;
+				else
+					_valid = true;
+			}
+		}
+		protected function get hierState() : Boolean
+		{
+			return (_nonHierarchical.length == 0);
+		}
+		
+		
+		/**
+		 * @private Functions that performs some basic consistency validation.
+		 */
+		protected function validateURI() : Boolean
+		{
+			// Check the scheme
+			if (isAbsolute())
+			{
+				if (_scheme.length <= 1 || _scheme == UNKNOWN_SCHEME)
+				{
+					// we probably parsed a C:\ type path or no scheme
+					return false;
+				}
+				else if (verifyAlpha(_scheme) == false)
+					return false;  // Scheme contains bad characters
+			}
+			
+			if (hierState)
+			{
+				if (_path.search('\\') != -1)
+					return false;  // local path
+				else if (isRelative() == false && _scheme == UNKNOWN_SCHEME)
+					return false;  // It's an absolute URI, but it has a bad scheme
+			}
+			else
+			{
+				if (_nonHierarchical.search('\\') != -1)
+					return false;  // some kind of local path
+			}
+		
+			// Looks like it's ok.
+			return true;
+		}
+		
+		
+		/**
+		 * @private
+		 *
+		 * Given a URI in string format, parse that sucker into its basic
+		 * components and assign them to this object.  A URI is of the form:
+		 *    &lt;scheme&gt;:&lt;authority&gt;&lt;path&gt;?&lt;query&gt;#&lt;fragment&gt;
+		 *
+		 * For simplicity, we parse the URI in the following order:
+		 * 		
+		 *		1. Fragment (anchors)
+		 * 		2. Query	(CGI stuff)
+		 * 		3. Scheme	("http")
+		 * 		4. Authority (host name)
+		 * 		5. Username/Password (if any)
+		 * 		6. Port		(server port if any)
+		 *		7. Path		(/homepages/mypage.html)
+		 *
+		 * The reason for this order is to minimize any parsing ambiguities.
+		 * Fragments and queries can contain almost anything (they are parts
+		 * that can contain custom data with their own syntax).  Parsing
+		 * them out first removes a large chance of parsing errors.  This
+		 * method expects well formed URI's, but performing the parse in
+		 * this order makes us a little more tolerant of user error.
+		 * 
+		 * REGEXP
+		 * Why doesn't this use regular expressions to parse the URI?  We
+		 * have found that in a real world scenario, URI's are not always
+		 * well formed.  Sometimes characters that should have been escaped
+		 * are not, and those situations would break a regexp pattern.  This
+		 * function attempts to be smart about what it is parsing based on
+		 * location of characters relative to eachother.  This function has
+		 * been proven through real-world use to parse the vast majority
+		 * of URI's correctly.
+		 *
+		 * NOTE
+		 * It is assumed that the string in URI form is escaped.  This function
+		 * does not escape anything.  If you constructed the URI string by
+		 * hand, and used this to parse in the URI and still need it escaped,
+		 * call forceEscape() on your URI object.
+		 *
+		 * Parsing Assumptions
+		 * This routine assumes that the URI being passed is well formed.
+		 * Passing things like local paths, malformed URI's, and the such
+		 * will result in parsing errors.  This function can handle
+		 * 	 - absolute hierarchical (e.g. "http://something.com/index.html),
+		 *   - relative hierarchical (e.g. "../images/flower.gif"), or
+		 *   - non-hierarchical URIs (e.g. "mailto:jsmith&#64;fungoo.com").
+		 * 
+		 * Anything else will probably result in a parsing error, or a bogus
+		 * URI object.
+		 * 
+		 * Note that non-hierarchical URIs *MUST* have a scheme, otherwise
+		 * they will be mistaken for relative URI's.
+		 * 
+		 * If you are not sure what is being passed to you (like manually
+		 * entered text from UI), you can construct a blank URI object and
+		 * call unknownToURI() passing in the unknown string.
+		 * 
+		 * @return	true if successful, false if there was some kind of
+		 * parsing error
+		 */
+		protected function parseURI(uri:String) : Boolean
+		{
+			var baseURI:String = uri;
+			var index:int, index2:int;
+		
+			// Make sure this object is clean before we start.  If it was used
+			// before and we are now parsing a new URI, we don't want any stale
+			// info lying around.
+			initialize();
+		
+			// Remove any fragments (anchors) from the URI
+			index = baseURI.indexOf("#");
+			if (index != -1)
+			{
+				// Store the fragment piece if any
+				if (baseURI.length > (index + 1)) // +1 is to skip the '#'
+					_fragment = baseURI.substr(index + 1, baseURI.length - (index + 1)); 
+		
+				// Trim off the fragment
+				baseURI = baseURI.substr(0, index);
+			}
+		
+			// We need to strip off any CGI parameters (eg '?param=bob')
+			index = baseURI.indexOf("?");
+			if (index != -1)
+			{
+				if (baseURI.length > (index + 1))
+					_query = baseURI.substr(index + 1, baseURI.length - (index + 1)); // +1 is to skip the '?'
+		
+				// Trim off the query
+				baseURI = baseURI.substr(0, index);
+			}
+		
+			// Now try to find the scheme part
+			index = baseURI.search(':');
+			index2 = baseURI.search('/');
+		
+			var containsColon:Boolean = (index != -1);
+			var containsSlash:Boolean = (index2 != -1);
+		
+			// This value is indeterminate if "containsColon" is false.
+			// (if there is no colon, does the slash come before or
+			// after said non-existing colon?)
+			var colonBeforeSlash:Boolean = (!containsSlash || index < index2);
+		
+			// If it has a colon and it's before the first slash, we will treat
+			// it as a scheme.  If a slash is before a colon, there must be a
+			// stray colon in a path or something.  In which case, the colon is
+			// not the separator for the scheme.  Technically, we could consider
+			// this an error, but since this is not an ambiguous state (we know
+			// 100% that this has no scheme), we will keep going.
+			if (containsColon && colonBeforeSlash)
+			{
+				// We found a scheme
+				_scheme = baseURI.substr(0, index);
+				
+				// Normalize the scheme
+				_scheme = _scheme.toLowerCase();
+		
+				baseURI = baseURI.substr(index + 1);
+		
+				if (baseURI.substr(0, 2) == "//")
+				{
+					// This is a hierarchical URI
+					_nonHierarchical = "";
+		
+					// Trim off the "//"
+					baseURI = baseURI.substr(2, baseURI.length - 2);
+				}
+				else
+				{
+					// This is a non-hierarchical URI like "mailto:bob@mail.com"
+					_nonHierarchical = baseURI;
+		
+					if ((_valid = validateURI()) == false)
+						initialize();  // Bad URI.  Clear it.
+		
+					// No more parsing to do for this case
+					return isValid();
+				}
+			}
+			else
+			{
+				// No scheme.  We will consider this a relative URI
+				_scheme = "";
+				_relative = true;
+				_nonHierarchical = "";
+			}
+		
+			// Ok, what we have left is everything after the <scheme>://
+		
+			// Now that we have stripped off any query and fragment parts, we
+			// need to split the authority from the path
+		
+			if (isRelative())
+			{
+				// Don't bother looking for the authority.  It's a relative URI
+				_authority = "";
+				_port = "";
+				_path = baseURI;
+			}
+			else
+			{
+				// Check for malformed UNC style file://///server/type/path/
+				// By the time we get here, we have already trimmed the "file://"
+				// so baseURI will be ///server/type/path.  If baseURI only
+				// has one slash, we leave it alone because that is valid (that
+				// is the case of "file:///path/to/file.txt" where there is no
+				// server - implicit "localhost").
+				if (baseURI.substr(0, 2) == "//")
+				{
+					// Trim all leading slashes
+					while(baseURI.charAt(0) == "/")
+						baseURI = baseURI.substr(1, baseURI.length - 1);
+				}
+		
+				index = baseURI.search('/');
+				if (index == -1)
+				{
+					// No path.  We must have passed something like "http://something.com"
+					_authority = baseURI;
+					_path = "";
+				}
+				else
+				{
+					_authority = baseURI.substr(0, index);
+					_path = baseURI.substr(index, baseURI.length - index);
+				}
+		
+				// Check to see if the URI has any username or password information.
+				// For example:  ftp://username:password@server.com
+				index = _authority.search('@');
+				if (index != -1)
+				{
+					// We have a username and possibly a password
+					_username = _authority.substr(0, index);
+		
+					// Remove the username/password from the authority
+					_authority = _authority.substr(index + 1);  // Skip the '@'
+		
+					// Now check to see if the username also has a password
+					index = _username.search(':');
+					if (index != -1)
+					{
+						_password = _username.substring(index + 1, _username.length);
+						_username = _username.substr(0, index);
+					}
+					else
+						_password = "";
+				}
+				else
+				{
+					_username = "";
+					_password = "";
+				}
+		
+				// Lastly, check to see if the authorty has a port number.
+				// This is parsed after the username/password to avoid conflicting
+				// with the ':' in the 'username:password' if one exists.
+				index = _authority.search(':');
+				if (index != -1)
+				{
+					_port = _authority.substring(index + 1, _authority.length);  // skip the ':'
+					_authority = _authority.substr(0, index);
+				}
+				else
+				{
+					_port = "";
+				}
+				
+				// Lastly, normalize the authority.  Domain names
+				// are case insensitive.
+				_authority = _authority.toLowerCase();
+			}
+		
+			if ((_valid = validateURI()) == false)
+				initialize();  // Bad URI.  Clear it
+		
+			return isValid();
+		}
+		
+		
+		/********************************************************************
+		 * Copy function.
+		 */
+		public function copyURI(uri:URI) : void
+		{
+			this._scheme = uri._scheme;
+			this._authority = uri._authority;
+			this._username = uri._username;
+			this._password = uri._password;
+			this._port = uri._port;
+			this._path = uri._path;
+			this._query = uri._query;
+			this._fragment = uri._fragment;
+			this._nonHierarchical = uri._nonHierarchical;
+		
+			this._valid = uri._valid;
+			this._relative = uri._relative;
+		}
+		
+		
+		/**
+		 * @private
+		 * Checks if the given string only contains a-z or A-Z.
+		 */
+		protected function verifyAlpha(str:String) : Boolean
+		{
+			var pattern:RegExp = /[^a-z]/;
+			var index:int;
+			
+			str = str.toLowerCase();
+			index = str.search(pattern);
+			
+			if (index == -1)
+				return true;
+			else
+				return false;
+		}
+		
+		/**
+		 * Is this a valid URI?
+		 * 
+		 * @return true if this object represents a valid URI, false
+		 * otherwise.
+		 */
+		public function isValid() : Boolean
+		{ 
+			return this._valid;
+		}
+		
+		
+		/**
+		 * Is this URI an absolute URI?  An absolute URI is a complete, fully
+		 * qualified reference to a resource.  e.g. http://site.com/index.htm
+		 * Non-hierarchical URI's are always absolute.
+		 */
+		public function isAbsolute() : Boolean
+		{ 
+			return !this._relative;
+		}
+		
+		
+		/**
+		 * Is this URI a relative URI?  Relative URI's do not have a scheme
+		 * and only contain a relative path with optional anchor and query
+		 * parts.  e.g. "../reports/index.htm".  Non-hierarchical URI's
+		 * will never be relative.
+		 */
+		public function isRelative() : Boolean
+		{ 
+			return this._relative;
+		}
+		
+		
+		/**
+		 * Does this URI point to a resource that is a directory/folder?
+		 * The URI specification dictates that any path that ends in a slash
+		 * is a directory.  This is needed to be able to perform correct path
+		 * logic when combining relative URI's with absolute URI's to
+		 * obtain the correct absolute URI to a resource.
+		 * 
+		 * @see URI.chdir
+		 * 
+		 * @return true if this URI represents a directory resource, false
+		 * if this URI represents a file resource.
+		 */
+		public function isDirectory() : Boolean
+		{
+			if (_path.length == 0)
+				return false;
+		
+			return (_path.charAt(path.length - 1) == '/');
+		}
+		
+		
+		/**
+		 * Is this URI a hierarchical URI? URI's can be  
+		 */
+		public function isHierarchical() : Boolean
+		{ 
+			return hierState;
+		}
+				
+		
+		/**
+		 * The scheme of the URI.
+		 */
+		public function get scheme() : String
+		{ 
+			return URI.unescapeChars(_scheme);
+		}
+		public function set scheme(schemeStr:String) : void
+		{
+			// Normalize the scheme
+			var normalized:String = schemeStr.toLowerCase();
+			_scheme = URI.fastEscapeChars(normalized, URI.URIschemeExcludedBitmap);
+		}
+		
+		
+		/**
+		 * The authority (host) of the URI.  Only valid for
+		 * hierarchical URI's.  If the URI is relative, this will
+		 * be an empty string. When setting this value, the string
+		 * given is assumed to be unescaped.  When retrieving this
+		 * value, the resulting string is unescaped.
+		 */
+		public function get authority() : String
+		{ 
+			return URI.unescapeChars(_authority);
+		}
+		public function set authority(authorityStr:String) : void
+		{
+			// Normalize the authority
+			authorityStr = authorityStr.toLowerCase();
+			
+			_authority = URI.fastEscapeChars(authorityStr,
+				URI.URIauthorityExcludedBitmap);
+			
+			// Only hierarchical URI's can have an authority, make
+			// sure this URI is of the proper format.
+			this.hierState = true;
+		}
+		
+		
+		/**
+		 * The username of the URI.  Only valid for hierarchical
+		 * URI's.  If the URI is relative, this will be an empty
+		 * string.
+		 * 
+		 * <p>The URI specification allows for authentication
+		 * credentials to be embedded in the URI as such:</p>
+		 * 
+		 * <p>http://user:passwd&#64;host/path/to/file.htm</p>
+		 * 
+		 * <p>When setting this value, the string
+		 * given is assumed to be unescaped.  When retrieving this
+		 * value, the resulting string is unescaped.</p>
+		 */
+		public function get username() : String
+		{
+			return URI.unescapeChars(_username);
+		}
+		public function set username(usernameStr:String) : void
+		{
+			_username = URI.fastEscapeChars(usernameStr, URI.URIuserpassExcludedBitmap);
+			
+			// Only hierarchical URI's can have a username.
+			this.hierState = true;
+		}
+		
+		
+		/**
+		 * The password of the URI.  Similar to username.
+		 * @see URI.username
+		 */
+		public function get password() : String
+		{
+			return URI.unescapeChars(_password);
+		}
+		public function set password(passwordStr:String) : void
+		{
+			_password = URI.fastEscapeChars(passwordStr,
+				URI.URIuserpassExcludedBitmap);
+			
+			// Only hierarchical URI's can have a password.
+			this.hierState = true;
+		}
+		
+		
+		/**
+		 * The host port number.  Only valid for hierarchical URI's.  If
+		 * the URI is relative, this will be an empty string. URI's can
+		 * contain the port number of the remote host:
+		 * 
+		 * <p>http://site.com:8080/index.htm</p>
+		 */
+		public function get port() : String
+		{ 
+			return URI.unescapeChars(_port);
+		}
+		public function set port(portStr:String) : void
+		{
+			_port = URI.escapeChars(portStr);
+			
+			// Only hierarchical URI's can have a port.
+			this.hierState = true;
+		}
+		
+		
+		/**
+		 * The path portion of the URI.  Only valid for hierarchical
+		 * URI's.  When setting this value, the string
+		 * given is assumed to be unescaped.  When retrieving this
+		 * value, the resulting string is unescaped.
+		 * 
+		 * <p>The path portion can be in one of two formats. 1) an absolute
+		 * path, or 2) a relative path.  An absolute path starts with a
+		 * slash ('/'), a relative path does not.</p>
+		 * 
+		 * <p>An absolute path may look like:</p>
+		 * <listing>/full/path/to/my/file.htm</listing>
+		 * 
+		 * <p>A relative path may look like:</p>
+		 * <listing>
+		 * path/to/my/file.htm
+		 * ../images/logo.gif
+		 * ../../reports/index.htm
+		 * </listing>
+		 * 
+		 * <p>Paths can be absolute or relative.  Note that this not the same as
+		 * an absolute or relative URI.  An absolute URI can only have absolute
+		 * paths.  For example:</p>
+		 * 
+		 * <listing>http:/site.com/path/to/file.htm</listing>
+		 * 
+		 * <p>This absolute URI has an absolute path of "/path/to/file.htm".</p>
+		 * 
+		 * <p>Relative URI's can have either absolute paths or relative paths.
+		 * All of the following relative URI's are valid:</p>
+		 * 
+		 * <listing>
+		 * /absolute/path/to/file.htm
+		 * path/to/file.htm
+		 * ../path/to/file.htm
+		 * </listing>
+		 */
+		public function get path() : String
+		{ 
+			return URI.unescapeChars(_path);
+		}
+		public function set path(pathStr:String) : void
+		{	
+			this._path = URI.fastEscapeChars(pathStr, URI.URIpathExcludedBitmap);
+		
+			if (this._scheme == UNKNOWN_SCHEME)
+			{
+				// We set the path.  This is a valid URI now.
+				this._scheme = "";
+			}
+		
+			// Only hierarchical URI's can have a path.
+			hierState = true;
+		}
+		
+		
+		/**
+		 * The query (CGI) portion of the URI.  This part is valid for
+		 * both hierarchical and non-hierarchical URI's.
+		 * 
+		 * <p>This accessor should only be used if a custom query syntax
+		 * is used.  This URI class supports the common "param=value"
+		 * style query syntax via the get/setQueryValue() and
+		 * get/setQueryByMap() functions.  Those functions should be used
+		 * instead if the common syntax is being used.
+		 * 
+		 * <p>The URI RFC does not specify any particular
+		 * syntax for the query part of a URI.  It is intended to allow
+		 * any format that can be agreed upon by the two communicating hosts.
+		 * However, most systems have standardized on the typical CGI
+		 * format:</p>
+		 * 
+		 * <listing>http://site.com/script.php?param1=value1&param2=value2</listing>
+		 * 
+		 * <p>This class has specific support for this query syntax</p>
+		 * 
+		 * <p>This common query format is an array of name/value
+		 * pairs with its own syntax that is different from the overall URI
+		 * syntax.  The query has its own escaping logic.  For a query part
+		 * to be properly escaped and unescaped, it must be split into its
+		 * component parts.  This accessor escapes/unescapes the entire query
+		 * part without regard for it's component parts.  This has the
+		 * possibliity of leaving the query string in an ambiguious state in
+		 * regards to its syntax.  If the contents of the query part are
+		 * important, it is recommended that get/setQueryValue() or
+		 * get/setQueryByMap() are used instead.</p>
+		 * 
+		 * If a different query syntax is being used, a subclass of URI
+		 * can be created to handle that specific syntax.
+		 *  
+		 * @see URI.getQueryValue, URI.getQueryByMap
+		 */
+		public function get query() : String
+		{ 
+			return URI.unescapeChars(_query);
+		}
+		public function set query(queryStr:String) : void
+		{
+			_query = URI.fastEscapeChars(queryStr, URI.URIqueryExcludedBitmap);
+			
+			// both hierarchical and non-hierarchical URI's can
+			// have a query.  Do not set the hierState.
+		}
+		
+		/**
+		 * Accessor to the raw query data.  If you are using a custom query
+		 * syntax, this accessor can be used to get and set the query part
+		 * directly with no escaping/unescaping.  This should ONLY be used
+		 * if your application logic is handling custom query logic and
+		 * handling the proper escaping of the query part.
+		 */
+		public function get queryRaw() : String
+		{
+			return _query;
+		}
+		public function set queryRaw(queryStr:String) : void
+		{
+			_query = queryStr;
+		}
+
+
+		/**
+		 * The fragment (anchor) portion of the URI.  This is valid for
+		 * both hierarchical and non-hierarchical URI's.
+		 */
+		public function get fragment() : String
+		{ 
+			return URI.unescapeChars(_fragment);
+		}
+		public function set fragment(fragmentStr:String) : void
+		{
+			_fragment = URI.fastEscapeChars(fragmentStr, URIfragmentExcludedBitmap);
+
+			// both hierarchical and non-hierarchical URI's can
+			// have a fragment.  Do not set the hierState.
+		}
+		
+		
+		/**
+		 * The non-hierarchical part of the URI.  For example, if
+		 * this URI object represents "mailto:somebody&#64;company.com",
+		 * this will contain "somebody&#64;company.com".  This is valid only
+		 * for non-hierarchical URI's.  
+		 */
+		public function get nonHierarchical() : String
+		{ 
+			return URI.unescapeChars(_nonHierarchical);
+		}
+		public function set nonHierarchical(nonHier:String) : void
+		{
+			_nonHierarchical = URI.fastEscapeChars(nonHier, URInonHierexcludedBitmap);
+			
+			// This is a non-hierarchical URI.
+			this.hierState = false;
+		}
+		
+		
+		/**
+		 * Quick shorthand accessor to set the parts of this URI.
+		 * The given parts are assumed to be in unescaped form.  If
+		 * the URI is non-hierarchical (e.g. mailto:) you will need
+		 * to call SetScheme() and SetNonHierarchical().
+		 */
+		public function setParts(schemeStr:String, authorityStr:String,
+				portStr:String, pathStr:String, queryStr:String,
+				fragmentStr:String) : void
+		{
+			this.scheme = schemeStr;
+			this.authority = authorityStr;
+			this.port = portStr;
+			this.path = pathStr;
+			this.query = queryStr;
+			this.fragment = fragmentStr;
+
+			hierState = true;
+		}
+		
+		
+		/**
+		 * URI escapes the given character string.  This is similar in function
+		 * to the global encodeURIComponent() function in ActionScript, but is
+		 * slightly different in regards to which characters get escaped.  This
+		 * escapes the characters specified in the URIbaselineExluded set (see class
+		 * static members).  This is needed for this class to work properly.
+		 * 
+		 * <p>If a different set of characters need to be used for the escaping,
+		 * you may use fastEscapeChars() and specify a custom URIEncodingBitmap
+		 * that contains the characters your application needs escaped.</p>
+		 * 
+		 * <p>Never pass a full URI to this function.  A URI can only be properly
+		 * escaped/unescaped when split into its component parts (see RFC 3986
+		 * section 2.4).  This is due to the fact that the URI component separators
+		 * could be characters that would normally need to be escaped.</p>
+		 * 
+		 * @param unescaped character string to be escaped.
+		 * 
+		 * @return	escaped character string
+		 * 
+		 * @see encodeURIComponent
+		 * @see fastEscapeChars
+		 */
+		static public function escapeChars(unescaped:String) : String
+		{
+			// This uses the excluded set by default.
+			return fastEscapeChars(unescaped, URI.URIbaselineExcludedBitmap);
+		}
+		
+
+		/**
+		 * Unescape any URI escaped characters in the given character
+		 * string.
+		 * 
+		 * <p>Never pass a full URI to this function.  A URI can only be properly
+		 * escaped/unescaped when split into its component parts (see RFC 3986
+		 * section 2.4).  This is due to the fact that the URI component separators
+		 * could be characters that would normally need to be escaped.</p>
+		 * 
+		 * @param escaped the escaped string to be unescaped.
+		 * 
+		 * @return	unescaped string.
+		 */
+		static public function unescapeChars(escaped:String /*, onlyHighASCII:Boolean = false*/) : String
+		{
+			// We can just use the default AS function.  It seems to
+			// decode everything correctly
+			var unescaped:String;
+			unescaped = decodeURIComponent(escaped);
+			return unescaped;
+		}
+		
+		/**
+		 * Performance focused function that escapes the given character
+		 * string using the given URIEncodingBitmap as the rule for what
+		 * characters need to be escaped.  This function is used by this
+		 * class and can be used externally to this class to perform
+		 * escaping on custom character sets.
+		 * 
+		 * <p>Never pass a full URI to this function.  A URI can only be properly
+		 * escaped/unescaped when split into its component parts (see RFC 3986
+		 * section 2.4).  This is due to the fact that the URI component separators
+		 * could be characters that would normally need to be escaped.</p>
+		 * 
+		 * @param unescaped		the unescaped string to be escaped
+		 * @param bitmap		the set of characters that need to be escaped
+		 * 
+		 * @return	the escaped string.
+		 */
+		static public function fastEscapeChars(unescaped:String, bitmap:URIEncodingBitmap) : String
+		{
+			var escaped:String = "";
+			var c:String;
+			var x:int, i:int;
+			
+			for (i = 0; i < unescaped.length; i++)
+			{
+				c = unescaped.charAt(i);
+				
+				x = bitmap.ShouldEscape(c);
+				if (x)
+				{
+					c = x.toString(16);
+					if (c.length == 1)
+						c = "0" + c;
+						
+					c = "%" + c;
+					c = c.toUpperCase();
+				}
+				
+				escaped += c;
+			}
+			
+			return escaped;
+		}
+
+		
+		/**
+		 * Is this URI of a particular scheme type?  For example,
+		 * passing "http" to a URI object that represents the URI
+		 * "http://site.com/" would return true.
+		 * 
+		 * @param scheme	scheme to check for
+		 * 
+		 * @return true if this URI object is of the given type, false
+		 * otherwise.
+		 */
+		public function isOfType(scheme:String) : Boolean
+		{
+			// Schemes are never case sensitive.  Ignore case.
+			scheme = scheme.toLowerCase();
+			return (this._scheme == scheme);
+		}
+
+
+		/**
+		 * Get the value for the specified named in the query part.  This
+		 * assumes the query part of the URI is in the common
+		 * "name1=value1&name2=value2" syntax.  Do not call this function
+		 * if you are using a custom query syntax.
+		 * 
+		 * @param name	name of the query value to get.
+		 * 
+		 * @return the value of the query name, empty string if the
+		 * query name does not exist.
+		 */
+		public function getQueryValue(name:String) : String
+		{
+			var map:Object;
+			var item:String;
+			var value:String;
+		
+			map = getQueryByMap();
+		
+			for (item in map)
+			{
+				if (item == name)
+				{
+					value = map[item];
+					return value;
+				}
+			}
+		
+			// Didn't find the specified key
+			return new String("");
+		}
+		
+
+		/**
+		 * Set the given value on the given query name.  If the given name
+		 * does not exist, it will automatically add this name/value pair
+		 * to the query.  If null is passed as the value, it will remove
+		 * the given item from the query.
+		 * 
+		 * <p>This automatically escapes any characters that may conflict with
+		 * the query syntax so that they are "safe" within the query.  The
+		 * strings passed are assumed to be literal unescaped name and value.</p>
+		 * 
+		 * @param name	name of the query value to set
+		 * @param value	value of the query item to set.  If null, this will
+		 * force the removal of this item from the query.
+		 */
+		public function setQueryValue(name:String, value:String) : void
+		{
+			var map:Object;
+
+			map = getQueryByMap();
+		
+			// If the key doesn't exist yet, this will create a new pair in
+			// the map.  If it does exist, this will overwrite the previous
+			// value, which is what we want.
+			map[name] = value;
+		
+			setQueryByMap(map);
+		}
+
+		
+		/**
+		 * Get the query of the URI in an Object class that allows for easy
+		 * access to the query data via Object accessors.  For example:
+		 * 
+		 * <listing>
+		 * var query:Object = uri.getQueryByMap();
+		 * var value:String = query["param"];    // get a value
+		 * query["param2"] = "foo";   // set a new value
+		 * </listing>
+		 * 
+		 * @return Object that contains the name/value pairs of the query.
+		 * 
+		 * @see #setQueryByMap
+		 * @see #getQueryValue
+		 * @see #setQueryValue
+		 */
+		public function getQueryByMap() : Object
+		{
+			var queryStr:String;
+			var pair:String;
+			var pairs:Array;
+			var item:Array;
+			var name:String, value:String;
+			var index:int;
+			var map:Object = new Object();
+		
+		
+			// We need the raw query string, no unescaping.
+			queryStr = this._query;
+			
+			pairs = queryStr.split('&');
+			for each (pair in pairs)
+			{
+				if (pair.length == 0)
+				  continue;
+				  
+				item = pair.split('=');
+				
+				if (item.length > 0)
+					name = item[0];
+				else
+					continue;  // empty array
+				
+				if (item.length > 1)
+					value = item[1];
+				else
+					value = "";
+					
+				name = queryPartUnescape(name);
+				value = queryPartUnescape(value);
+				
+				map[name] = value;
+			}
+	
+			return map;
+		}
+		
+
+		/**
+		 * Set the query part of this URI using the given object as the
+		 * content source.  Any member of the object that has a value of
+		 * null will not be in the resulting query.
+		 * 
+		 * @param map	object that contains the name/value pairs as
+		 *    members of that object.
+		 * 
+		 * @see #getQueryByMap
+		 * @see #getQueryValue
+		 * @see #setQueryValue
+		 */
+		public function setQueryByMap(map:Object) : void
+		{
+			var item:String;
+			var name:String, value:String;
+			var queryStr:String = "";
+			var tmpPair:String;
+			var foo:String;
+		
+			for (item in map)
+			{
+				name = item;
+				value = map[item];
+		
+				if (value == null)
+					value = "";
+				
+				// Need to escape the name/value pair so that they
+				// don't conflict with the query syntax (specifically
+				// '=', '&', and <whitespace>).
+				name = queryPartEscape(name);
+				value = queryPartEscape(value);
+				
+				tmpPair = name;
+				
+				if (value.length > 0)
+				{
+					tmpPair += "=";
+					tmpPair += value;
+				}
+
+				if (queryStr.length != 0)
+					queryStr += '&';  // Add the separator
+		
+				queryStr += tmpPair;
+			}
+		
+			// We don't want to escape.  We already escaped the
+			// individual name/value pairs.  If we escaped the
+			// query string again by assigning it to "query",
+			// we would have double escaping.
+			_query = queryStr;
+		}
+		
+		
+		/**
+		 * Similar to Escape(), except this also escapes characters that
+		 * would conflict with the name/value pair query syntax.  This is
+		 * intended to be called on each individual "name" and "value"
+		 * in the query making sure that nothing in the name or value
+		 * strings contain characters that would conflict with the query
+		 * syntax (e.g. '=' and '&').
+		 * 
+		 * @param unescaped		unescaped string that is to be escaped.
+		 * 
+		 * @return escaped string.
+		 * 
+		 * @see #queryUnescape
+		 */
+		static public function queryPartEscape(unescaped:String) : String
+		{
+			var escaped:String = unescaped;
+			escaped = URI.fastEscapeChars(unescaped, URI.URIqueryPartExcludedBitmap);
+			return escaped;
+		}
+		
+
+		/**
+		 * Unescape the individual name/value string pairs.
+		 * 
+		 * @param escaped	escaped string to be unescaped
+		 * 
+		 * @return unescaped string
+		 * 
+		 * @see #queryEscape
+		 */
+		static public function queryPartUnescape(escaped:String) : String
+		{
+			var unescaped:String = escaped;
+			unescaped = unescapeChars(unescaped);
+			return unescaped;
+		}
+		
+		/**
+		 * Output this URI as a string.  The resulting string is properly
+		 * escaped and well formed for machine processing.
+		 */
+		public function toString() : String
+		{
+			if (this == null)
+				return "";
+			else
+				return toStringInternal(false);
+		}
+		
+		/**
+		 * Output the URI as a string that is easily readable by a human.
+		 * This outputs the URI with all escape sequences unescaped to
+		 * their character representation.  This makes the URI easier for
+		 * a human to read, but the URI could be completely invalid
+		 * because some unescaped characters may now cause ambiguous parsing.
+		 * This function should only be used if you want to display a URI to
+		 * a user.  This function should never be used outside that specific
+		 * case.
+		 * 
+		 * @return the URI in string format with all escape sequences
+		 * unescaped.
+		 * 
+		 * @see #toString
+		 */
+		public function toDisplayString() : String
+		{
+			return toStringInternal(true);
+		}
+		
+		
+		/**
+		 * @private
+		 * 
+		 * The guts of toString()
+		 */
+		protected function toStringInternal(forDisplay:Boolean) : String
+		{
+			var uri:String = "";
+			var part:String = "";
+		
+			if (isHierarchical() == false)
+			{
+				// non-hierarchical URI
+		
+				uri += (forDisplay ? this.scheme : _scheme);
+				uri += ":";
+				uri += (forDisplay ? this.nonHierarchical : _nonHierarchical);
+			}
+			else
+			{
+				// Hierarchical URI
+		
+				if (isRelative() == false)
+				{
+					// If it is not a relative URI, then we want the scheme and
+					// authority parts in the string.  If it is relative, we
+					// do NOT want this stuff.
+		
+					if (_scheme.length != 0)
+					{
+						part = (forDisplay ? this.scheme : _scheme);
+						uri += part + ":";
+					}
+		
+					if (_authority.length != 0 || isOfType("file"))
+					{
+						uri += "//";
+		
+						// Add on any username/password associated with this
+						// authority
+						if (_username.length != 0)
+						{
+							part = (forDisplay ? this.username : _username);
+							uri += part;
+		
+							if (_password.length != 0)
+							{
+								part = (forDisplay ? this.password : _password);
+								uri += ":" + part;
+							}
+		
+							uri += "@";
+						}
+		
+						// add the authority
+						part = (forDisplay ? this.authority : _authority);
+						uri += part;
+		
+						// Tack on the port number, if any
+						if (port.length != 0)
+							uri += ":" + port;
+					}
+				}
+		
+				// Tack on the path
+				part = (forDisplay ? this.path : _path);
+				uri += part;
+		
+			} // end hierarchical part
+		
+			// Both non-hier and hierarchical have query and fragment parts
+		
+			// Add on the query and fragment parts
+			if (_query.length != 0)
+			{
+				part = (forDisplay ? this.query : _query);
+				uri += "?" + part;
+			}
+		
+			if (fragment.length != 0)
+			{
+				part = (forDisplay ? this.fragment : _fragment);
+				uri += "#" + part;
+			}
+		
+			return uri;
+		}
+	
+		/**
+		 * Forcefully ensure that this URI is properly escaped.
+		 * 
+		 * <p>Sometimes URI's are constructed by hand using strings outside
+		 * this class.  In those cases, it is unlikely the URI has been
+		 * properly escaped.  This function forcefully escapes this URI
+		 * by unescaping each part and then re-escaping it.  If the URI
+		 * did not have any escaping, the first unescape will do nothing
+		 * and then the re-escape will properly escape everything.  If
+		 * the URI was already escaped, the unescape and re-escape will
+		 * essentally be a no-op.  This provides a safe way to make sure
+		 * a URI is in the proper escaped form.</p>
+		 */
+		public function forceEscape() : void
+		{
+			// The accessors for each of the members will unescape
+			// and then re-escape as we get and assign them.
+			
+			// Handle the parts that are common for both hierarchical
+			// and non-hierarchical URI's
+			this.scheme = this.scheme;
+			this.setQueryByMap(this.getQueryByMap());
+			this.fragment = this.fragment;
+			
+			if (isHierarchical())
+			{
+				this.authority = this.authority;
+				this.path = this.path;
+				this.port = this.port;
+				this.username = this.username;
+				this.password = this.password;
+			}
+			else
+			{
+				this.nonHierarchical = this.nonHierarchical;
+			}
+		}
+		
+		
+		/**
+		 * Does this URI point to a resource of the given file type?
+		 * Given a file extension (or just a file name, this will strip the
+		 * extension), check to see if this URI points to a file of that
+		 * type.
+		 * 
+		 * @param extension 	string that contains a file extension with or
+		 * without a dot ("html" and ".html" are both valid), or a file
+		 * name with an extension (e.g. "index.html").
+		 * 
+		 * @return true if this URI points to a resource with the same file
+		 * file extension as the extension provided, false otherwise.
+		 */
+		public function isOfFileType(extension:String) : Boolean
+		{
+			var thisExtension:String;
+			var index:int;
+		
+			index = extension.lastIndexOf(".");
+			if (index != -1)
+			{
+				// Strip the extension
+				extension = extension.substr(index + 1);
+			}
+			else
+			{
+				// The caller passed something without a dot in it.  We
+				// will assume that it is just a plain extension (e.g. "html").
+				// What they passed is exactly what we want
+			}
+		
+			thisExtension = getExtension(true);
+		
+			if (thisExtension == "")
+				return false;
+		
+			// Compare the extensions ignoring case
+			if (compareStr(thisExtension, extension, false) == 0)
+				return true;
+			else
+				return false;
+		}
+		
+		
+		/**
+		 * Get the ".xyz" file extension from the filename in the URI.
+		 * For example, if we have the following URI:
+		 * 
+		 * <listing>http://something.com/path/to/my/page.html?form=yes&name=bob#anchor</listing>
+		 * 
+		 * <p>This will return ".html".</p>
+		 * 
+		 * @param minusDot   If true, this will strip the dot from the extension.
+		 * If true, the above example would have returned "html".
+		 * 
+		 * @return  the file extension
+		 */
+		public function getExtension(minusDot:Boolean = false) : String
+		{
+			var filename:String = getFilename();
+			var extension:String;
+			var index:int;
+		
+			if (filename == "")
+				return String("");
+		
+			index = filename.lastIndexOf(".");
+		
+			// If it doesn't have an extension, or if it is a "hidden" file,
+			// it doesn't have an extension.  Hidden files on unix start with
+			// a dot (e.g. ".login").
+			if (index == -1 || index == 0)
+				return String("");
+		
+			extension = filename.substr(index);
+		
+			// If the caller does not want the dot, remove it.
+			if (minusDot && extension.charAt(0) == ".")
+				extension = extension.substr(1);
+		
+			return extension;
+		}
+		
+		/**
+		 * Quick function to retrieve the file name off the end of a URI.
+		 * 
+		 * <p>For example, if the URI is:</p>
+		 * <listing>http://something.com/some/path/to/my/file.html</listing>
+		 * <p>this function will return "file.html".</p>
+		 * 
+		 * @param minusExtension true if the file extension should be stripped
+		 * 
+		 * @return the file name.  If this URI is a directory, the return
+		 * value will be empty string.
+		 */
+		public function getFilename(minusExtension:Boolean = false) : String
+		{
+			if (isDirectory())
+				return String("");
+		
+			var pathStr:String = this.path;
+			var filename:String;
+			var index:int;
+		
+			// Find the last path separator.
+			index = pathStr.lastIndexOf("/");
+		
+			if (index != -1)
+				filename = pathStr.substr(index + 1);
+			else
+				filename = pathStr;
+		
+			if (minusExtension)
+			{
+				// The caller has requested that the extension be removed
+				index = filename.lastIndexOf(".");
+		
+				if (index != -1)
+					filename = filename.substr(0, index);
+			}
+		
+			return filename;
+		}
+		
+		
+		/**
+		 * @private
+		 * Helper function to compare strings.
+		 * 
+		 * @return true if the two strings are identical, false otherwise.
+		 */
+		static protected function compareStr(str1:String, str2:String,
+			sensitive:Boolean = true) : Boolean
+		{
+			if (sensitive == false)
+			{
+				str1 = str1.toLowerCase();
+				str2 = str2.toLowerCase();
+			}
+			
+			return (str1 == str2)
+		}
+		
+		/**
+		 * Based on the type of this URI (http, ftp, etc.) get
+		 * the default port used for that protocol.  This is
+		 * just intended to be a helper function for the most
+		 * common cases.
+		 */
+		public function getDefaultPort() : String
+		{
+			if (_scheme == "http")
+				return String("80");
+			else if (_scheme == "ftp")
+				return String("21");
+			else if (_scheme == "file")
+				return String("");
+			else if (_scheme == "sftp")
+				return String("22"); // ssh standard port
+			else
+			{
+				// Don't know the port for this URI type
+				return String("");
+			}
+		}
+		
+		/**
+		 * @private
+		 * 
+		 * This resolves the given URI if the application has a
+		 * resolver interface defined.  This function does not
+		 * modify the passed in URI and returns a new URI.
+		 */
+		static protected function resolve(uri:URI) : URI
+		{
+			var copy:URI = new URI();
+			copy.copyURI(uri);
+			
+			if (_resolver != null)
+			{
+				// A resolver class has been registered.  Call it.
+				return _resolver.resolve(copy);
+			}
+			else
+			{
+				// No resolver.  Nothing to do, but we don't
+				// want to reuse the one passed in.
+				return copy;
+			}
+		}
+		
+		/**
+		 * Accessor to set and get the resolver object used by all URI
+		 * objects to dynamically resolve URI's before comparison.
+		 */
+		static public function set resolver(resolver:IURIResolver) : void
+		{
+			_resolver = resolver;
+		}
+		static public function get resolver() : IURIResolver
+		{
+			return _resolver;
+		}
+		
+		/**
+		 * Given another URI, return this URI object's relation to the one given.
+		 * URI's can have 1 of 4 possible relationships.  They can be unrelated,
+		 * equal, parent, or a child of the given URI.
+		 * 
+		 * @param uri	URI to compare this URI object to.
+		 * @param caseSensitive  true if the URI comparison should be done
+		 * taking case into account, false if the comparison should be
+		 * performed case insensitive.
+		 * 
+		 * @return URI.NOT_RELATED, URI.CHILD, URI.PARENT, or URI.EQUAL
+		 */
+		public function getRelation(uri:URI, caseSensitive:Boolean = true) : int
+		{
+			// Give the app a chance to resolve these URI's before we compare them.
+			var thisURI:URI = URI.resolve(this);
+			var thatURI:URI = URI.resolve(uri);
+			
+			if (thisURI.isRelative() || thatURI.isRelative())
+			{
+				// You cannot compare relative URI's due to their lack of context.
+				// You could have two relative URI's that look like:
+				//		../../images/
+				//		../../images/marketing/logo.gif
+				// These may appear related, but you have no overall context
+				// from which to make the comparison.  The first URI could be
+				// from one site and the other URI could be from another site.
+				return URI.NOT_RELATED;
+			}
+			else if (thisURI.isHierarchical() == false || thatURI.isHierarchical() == false)
+			{
+				// One or both of the URI's are non-hierarchical.
+				if (((thisURI.isHierarchical() == false) && (thatURI.isHierarchical() == true)) ||
+					((thisURI.isHierarchical() == true) && (thatURI.isHierarchical() == false)))
+				{
+					// XOR.  One is hierarchical and the other is
+					// non-hierarchical.  They cannot be compared.
+					return URI.NOT_RELATED;
+				}
+				else
+				{
+					// They are both non-hierarchical
+					if (thisURI.scheme != thatURI.scheme)
+						return URI.NOT_RELATED;
+		
+					if (thisURI.nonHierarchical != thatURI.nonHierarchical)
+						return URI.NOT_RELATED;
+						
+					// The two non-hierarcical URI's are equal.
+					return URI.EQUAL;
+				}
+			}
+			
+			// Ok, this URI and the one we are being compared to are both
+			// absolute hierarchical URI's.
+		
+			if (thisURI.scheme != thatURI.scheme)
+				return URI.NOT_RELATED;
+		
+			if (thisURI.authority != thatURI.authority)
+				return URI.NOT_RELATED;
+		
+			var thisPort:String = thisURI.port;
+			var thatPort:String = thatURI.port;
+			
+			// Different ports are considered completely different servers.
+			if (thisPort == "")
+				thisPort = thisURI.getDefaultPort();
+			if (thatPort == "")
+				thatPort = thatURI.getDefaultPort();
+		
+			// Check to see if the port is the default port.
+			if (thisPort != thatPort)
+				return URI.NOT_RELATED;
+		
+			if (compareStr(thisURI.path, thatURI.path, caseSensitive))
+				return URI.EQUAL;
+		
+			// Special case check.  If we are here, the scheme, authority,
+			// and port match, and it is not a relative path, but the
+			// paths did not match.  There is a special case where we
+			// could have:
+			//		http://something.com/
+			//		http://something.com
+			// Technically, these are equal.  So lets, check for this case.
+			var thisPath:String = thisURI.path;
+			var thatPath:String = thatURI.path;
+		
+			if ( (thisPath == "/" || thatPath == "/") &&
+				 (thisPath == "" || thatPath == "") )
+			{
+				// We hit the special case.  These two are equal.
+				return URI.EQUAL;
+			}
+		
+			// Ok, the paths do not match, but one path may be a parent/child
+			// of the other.  For example, we may have:
+			//		http://something.com/path/to/homepage/
+			//		http://something.com/path/to/homepage/images/logo.gif
+			// In this case, the first is a parent of the second (or the second
+			// is a child of the first, depending on which you compare to the
+			// other).  To make this comparison, we must split the path into
+			// its component parts (split the string on the '/' path delimiter).
+			// We then compare the 
+			var thisParts:Array, thatParts:Array;
+			var thisPart:String, thatPart:String;
+			var i:int;
+		
+			thisParts = thisPath.split("/");
+			thatParts = thatPath.split("/");
+		
+			if (thisParts.length > thatParts.length)
+			{
+				thatPart = thatParts[thatParts.length - 1];
+				if (thatPart.length > 0)
+				{
+					// if the last part is not empty, the passed URI is
+					// not a directory.  There is no way the passed URI
+					// can be a parent.
+					return URI.NOT_RELATED;
+				}
+				else
+				{
+					// Remove the empty trailing part
+					thatParts.pop();
+				}
+				
+				// This may be a child of the one passed in
+				for (i = 0; i < thatParts.length; i++)
+				{
+					thisPart = thisParts[i];
+					thatPart = thatParts[i];
+						
+					if (compareStr(thisPart, thatPart, caseSensitive) == false)
+						return URI.NOT_RELATED;
+				}
+		
+				return URI.CHILD;
+			}
+			else if (thisParts.length < thatParts.length)
+			{
+				thisPart = thisParts[thisParts.length - 1];
+				if (thisPart.length > 0)
+				{
+					// if the last part is not empty, this URI is not a
+					// directory.  There is no way this object can be
+					// a parent.
+					return URI.NOT_RELATED;
+				}
+				else
+				{
+					// Remove the empty trailing part
+					thisParts.pop();
+				}
+				
+				// This may be the parent of the one passed in
+				for (i = 0; i < thisParts.length; i++)
+				{
+					thisPart = thisParts[i];
+					thatPart = thatParts[i];
+		
+					if (compareStr(thisPart, thatPart, caseSensitive) == false)
+						return URI.NOT_RELATED;
+				}
+				
+				return URI.PARENT;
+			}
+			else
+			{
+				// Both URI's have the same number of path components, but
+				// it failed the equivelence check above.  This means that
+				// the two URI's are not related.
+				return URI.NOT_RELATED;
+			}
+			
+			// If we got here, the scheme and authority are the same,
+			// but the paths pointed to two different locations that
+			// were in different parts of the file system tree
+			return URI.NOT_RELATED;
+		}
+		
+		/**
+		 * Given another URI, return the common parent between this one
+		 * and the provided URI.
+		 * 
+		 * @param uri the other URI from which to find a common parent
+		 * @para caseSensitive true if this operation should be done
+		 * with case sensitive comparisons.
+		 * 
+		 * @return the parent URI if successful, null otherwise.
+		 */
+		public function getCommonParent(uri:URI, caseSensitive:Boolean = true) : URI
+		{
+			var thisURI:URI = URI.resolve(this);
+			var thatURI:URI = URI.resolve(uri);
+		
+			if(!thisURI.isAbsolute() || !thatURI.isAbsolute() ||
+				thisURI.isHierarchical() == false ||
+				thatURI.isHierarchical() == false)
+			{
+				// Both URI's must be absolute hierarchical for this to
+				// make sense.
+				return null;
+			}
+			
+			var relation:int = thisURI.getRelation(thatURI);
+			if (relation == URI.NOT_RELATED)
+			{
+				// The given URI is not related to this one.  No
+				// common parent.
+				return null;
+			}
+		
+			thisURI.chdir(".");
+			thatURI.chdir(".");
+			
+			var strBefore:String, strAfter:String;
+			do
+			{
+				relation = thisURI.getRelation(thatURI, caseSensitive);
+				if(relation == URI.EQUAL || relation == URI.PARENT)
+					break;
+		
+				// If strBefore and strAfter end up being the same,
+				// we know we are at the root of the path because
+				// chdir("..") is doing nothing.
+				strBefore = thisURI.toString();
+				thisURI.chdir("..");
+				strAfter = thisURI.toString();
+			}
+			while(strBefore != strAfter);
+		
+			return thisURI;
+		}
+		
+		
+		/**
+		 * This function is used to move around in a URI in a way similar
+		 * to the 'cd' or 'chdir' commands on Unix.  These operations are
+		 * completely string based, using the context of the URI to
+		 * determine the position within the path.  The heuristics used
+		 * to determine the action are based off Appendix C in RFC 2396.
+		 * 
+		 * <p>URI paths that end in '/' are considered paths that point to
+		 * directories, while paths that do not end in '/' are files.  For
+		 * example, if you execute chdir("d") on the following URI's:<br/>
+		 *    1.  http://something.com/a/b/c/  (directory)<br/>
+		 *    2.  http://something.com/a/b/c  (not directory)<br/>
+		 * you will get:<br/>
+		 *    1.  http://something.com/a/b/c/d<br/>
+		 *    2.  http://something.com/a/b/d<br/></p>
+		 * 
+		 * <p>See RFC 2396, Appendix C for more info.</p>
+		 * 
+		 * @param reference	the URI or path to "cd" to.
+		 * @param escape true if the passed reference string should be URI
+		 * escaped before using it.
+		 * 
+		 * @return true if the chdir was successful, false otherwise.
+		 */
+		public function chdir(reference:String, escape:Boolean = false) : Boolean
+		{
+			var uriReference:URI;
+			var ref:String = reference;
+		
+			if (escape)
+				ref = URI.escapeChars(reference);
+		
+			if (ref == "")
+			{
+				// NOOP
+				return true;
+			}
+			else if (ref.substr(0, 2) == "//")
+			{
+				// Special case.  This is an absolute URI but without the scheme.
+				// Take the scheme from this URI and tack it on.  This is
+				// intended to make working with chdir() a little more
+				// tolerant.
+				var f:String = this.scheme + ":" + ref;
+				
+				return constructURI(f);
+			}
+			else if (ref.charAt(0) == "?")
+			{
+				// A relative URI that is just a query part is essentially
+				// a "./?query".  We tack on the "./" here to make the rest
+				// of our logic work.
+				ref = "./" + ref;
+			}
+		
+			// Parse the reference passed in as a URI.  This way we
+			// get any query and fragments parsed out as well.
+			uriReference = new URI(ref);
+		
+			if (uriReference.isAbsolute() ||
+				uriReference.isHierarchical() == false)
+			{
+				// If the URI given is a full URI, it replaces this one.
+				copyURI(uriReference);
+				return true;
+			}
+		
+		
+			var thisPath:String, thatPath:String;
+			var thisParts:Array, thatParts:Array;
+			var thisIsDir:Boolean = false, thatIsDir:Boolean = false;
+			var thisIsAbs:Boolean = false, thatIsAbs:Boolean = false;
+			var lastIsDotOperation:Boolean = false;
+			var curDir:String;
+			var i:int;
+		
+			thisPath = this.path;
+			thatPath = uriReference.path;
+		
+			if (thisPath.length > 0)
+				thisParts = thisPath.split("/");
+			else
+				thisParts = new Array();
+				
+			if (thatPath.length > 0)
+				thatParts = thatPath.split("/");
+			else
+				thatParts = new Array();
+			
+			if (thisParts.length > 0 && thisParts[0] == "")
+			{
+				thisIsAbs = true;
+				thisParts.shift(); // pop the first one off the array
+			}
+			if (thisParts.length > 0 && thisParts[thisParts.length - 1] == "")
+			{
+				thisIsDir = true;
+				thisParts.pop();  // pop the last one off the array
+			}
+				
+			if (thatParts.length > 0 && thatParts[0] == "")
+			{
+				thatIsAbs = true;
+				thatParts.shift(); // pop the first one off the array
+			}
+			if (thatParts.length > 0 && thatParts[thatParts.length - 1] == "")
+			{
+				thatIsDir = true;
+				thatParts.pop();  // pop the last one off the array
+			}
+				
+			if (thatIsAbs)
+			{
+				// The reference is an absolute path (starts with a slash).
+				// It replaces this path wholesale.
+				this.path = uriReference.path;
+		
+				// And it inherits the query and fragment
+				this.queryRaw = uriReference.queryRaw;
+				this.fragment = uriReference.fragment;
+		
+				return true;
+			}
+			else if (thatParts.length == 0 && uriReference.query == "")
+			{
+				// The reference must have only been a fragment.  Fragments just
+				// get appended to whatever the current path is.  We don't want
+				// to overwrite any query that may already exist, so this case
+				// only takes on the new fragment.
+				this.fragment = uriReference.fragment;
+				return true;
+			}
+			else if (thisIsDir == false && thisParts.length > 0)
+			{
+				// This path ends in a file.  It goes away no matter what.
+				thisParts.pop();
+			}
+		
+			// By default, this assumes the query and fragment of the reference
+			this.queryRaw = uriReference.queryRaw;
+			this.fragment = uriReference.fragment;
+		
+			// Append the parts of the path from the passed in reference
+			// to this object's path.
+			thisParts = thisParts.concat(thatParts);
+					
+			for(i = 0; i < thisParts.length; i++)
+			{
+				curDir = thisParts[i];
+				lastIsDotOperation = false;
+		
+				if (curDir == ".")
+				{
+					thisParts.splice(i, 1);
+					i = i - 1;  // account for removing this item
+					lastIsDotOperation = true;
+				}
+				else if (curDir == "..")
+				{
+					if (i >= 1)
+					{
+						if (thisParts[i - 1] == "..")
+						{
+							// If the previous is a "..", we must have skipped
+							// it due to this URI being relative.  We can't
+							// collapse leading ".."s in a relative URI, so
+							// do nothing.
+						}
+						else
+						{
+							thisParts.splice(i - 1, 2);
+							i = i - 2;  // move back to account for the 2 we removed
+						}
+					}
+					else
+					{
+						// This is the first thing in the path.
+		
+						if (isRelative())
+						{
+							// We can't collapse leading ".."s in a relative
+							// path.  Do noting.
+						}
+						else
+						{
+							// This is an abnormal case.  We have dot-dotted up
+							// past the base of our "file system".  This is a
+							// case where we had a /path/like/this.htm and were
+							// given a path to chdir to like this:
+							// ../../../../../../mydir
+							// Obviously, it has too many ".." and will take us
+							// up beyond the top of the URI.  However, according
+							// RFC 2396 Appendix C.2, we should try to handle
+							// these abnormal cases appropriately.  In this case,
+							// we will do what UNIX command lines do if you are
+							// at the root (/) of the filesystem and execute:
+							// # cd ../../../../../bin
+							// Which will put you in /bin.  Essentially, the extra
+							// ".."'s will just get eaten.
+		
+							thisParts.splice(i, 1);
+							i = i - 1;  // account for the ".." we just removed
+						}
+					}
+		
+					lastIsDotOperation = true;
+				}
+			}
+			
+			var finalPath:String = "";
+		
+			// If the last thing in the path was a "." or "..", then this thing is a
+			// directory.  If the last thing isn't a dot-op, then we don't want to 
+			// blow away any information about the directory (hence the "|=" binary
+			// assignment).
+			thatIsDir = thatIsDir || lastIsDotOperation;
+		
+			// Reconstruct the path with the abs/dir info we have
+			finalPath = joinPath(thisParts, thisIsAbs, thatIsDir);
+		
+			// Set the path (automatically escaping it)
+			this.path = finalPath;
+		
+			return true;
+		}
+		
+		/**
+		 * @private
+		 * Join an array of path parts back into a URI style path string.
+		 * This is used by the various path logic functions to recombine
+		 * a path.  This is different than the standard Array.join()
+		 * function because we need to take into account the starting and
+		 * ending path delimiters if this is an absolute path or a
+		 * directory.
+		 * 
+		 * @param parts	the Array that contains strings of each path part.
+		 * @param isAbs		true if the given path is absolute
+		 * @param isDir		true if the given path is a directory
+		 * 
+		 * @return the combined path string.
+		 */
+		protected function joinPath(parts:Array, isAbs:Boolean, isDir:Boolean) : String
+		{
+			var pathStr:String = "";
+			var i:int;
+		
+			for (i = 0; i < parts.length; i++)
+			{
+				if (pathStr.length > 0)
+					pathStr += "/";
+		
+				pathStr += parts[i];
+			}
+		
+			// If this path is a directory, tack on the directory delimiter,
+			// but only if the path contains something.  Adding this to an
+			// empty path would make it "/", which is an absolute path that
+			// starts at the root.
+			if (isDir && pathStr.length > 0)
+				pathStr += "/";
+		
+			if (isAbs)
+				pathStr = "/" + pathStr;
+		
+			return pathStr;
+		}
+		
+		/**
+		 * Given an absolute URI, make this relative URI absolute using
+		 * the given URI as a base.  This URI instance must be relative
+		 * and the base_uri must be absolute.
+		 * 
+		 * @param base_uri	URI to use as the base from which to make
+		 * this relative URI into an absolute URI.
+		 * 
+		 * @return true if successful, false otherwise.
+		 */
+		public function makeAbsoluteURI(base_uri:URI) : Boolean
+		{
+			if (isAbsolute() || base_uri.isRelative())
+			{
+				// This URI needs to be relative, and the base needs to be
+				// absolute otherwise we won't know what to do!
+				return false;
+			}
+		
+			// Make a copy of the base URI.  We don't want to modify
+			// the passed URI.
+			var base:URI = new URI();
+			base.copyURI(base_uri);
+		
+			// ChDir on the base URI.  This will preserve any query
+			// and fragment we have.
+			if (base.chdir(toString()) == false)
+				return false;
+		
+			// It worked, so copy the base into this one
+			copyURI(base);
+		
+			return true;
+		}
+		
+		
+		/**
+		 * Given a URI to use as a base from which this object should be
+		 * relative to, convert this object into a relative URI.  For example,
+		 * if you have:
+		 * 
+		 * <listing>
+		 * var uri1:URI = new URI("http://something.com/path/to/some/file.html");
+		 * var uri2:URI = new URI("http://something.com/path/to/another/file.html");
+		 * 
+		 * uri1.MakeRelativePath(uri2);</listing>
+		 * 
+		 * <p>uri1 will have a final value of "../some/file.html"</p>
+		 * 
+		 * <p>Note! This function is brute force.  If you have two URI's
+		 * that are completely unrelated, this will still attempt to make
+		 * the relative URI.  In that case, you will most likely get a
+		 * relative path that looks something like:</p>
+		 * 
+		 * <p>../../../../../../some/path/to/my/file.html</p>
+		 * 
+		 * @param base_uri the URI from which to make this URI relative
+		 * 
+		 * @return true if successful, false if the base_uri and this URI
+		 * are not related, of if error.
+		 */
+		public function makeRelativeURI(base_uri:URI, caseSensitive:Boolean = true) : Boolean
+		{
+			var base:URI = new URI();
+			base.copyURI(base_uri);
+			
+			var thisParts:Array, thatParts:Array;
+			var finalParts:Array = new Array();
+			var thisPart:String, thatPart:String, finalPath:String;
+			var pathStr:String = this.path;
+			var queryStr:String = this.queryRaw;
+			var fragmentStr:String = this.fragment;
+			var i:int;
+			var diff:Boolean = false;
+			var isDir:Boolean = false;
+		
+			if (isRelative())
+			{
+				// We're already relative.
+				return true;
+			}
+		
+			if (base.isRelative())
+			{
+				// The base is relative.  A relative base doesn't make sense.
+				return false;
+			}
+		
+		
+			if ( (isOfType(base_uri.scheme) == false) ||
+				(this.authority != base_uri.authority) )
+			{
+				// The schemes and/or authorities are different.  We can't
+				// make a relative path to something that is completely
+				// unrelated.
+				return false;
+			}
+		
+			// Record the state of this URI
+			isDir = isDirectory();
+		
+			// We are based of the directory of the given URI.  We need to
+			// make sure the URI is pointing to a directory.  Changing
+			// directory to "." will remove any file name if the base is
+			// not a directory.
+			base.chdir(".");
+		
+			thisParts = pathStr.split("/");
+			thatParts = base.path.split("/");
+			
+			if (thisParts.length > 0 && thisParts[0] == "")
+				thisParts.shift();
+			
+			if (thisParts.length > 0 && thisParts[thisParts.length - 1] == "")
+			{
+				isDir = true;
+				thisParts.pop();
+			}
+			
+			if (thatParts.length > 0 && thatParts[0] == "")
+				thatParts.shift();
+			if (thatParts.length > 0 && thatParts[thatParts.length - 1] == "")
+				thatParts.pop();
+		
+		
+			// Now that we have the paths split into an array of directories,
+			// we can compare the two paths.  We start from the left of side
+			// of the path and start comparing.  When we either run out of
+			// directories (one path is longer than the other), or we find
+			// a directory that is different, we stop.  The remaining parts
+			// of each path is then used to determine the relative path.  For
+			// example, lets say we have:
+			//    path we want to make relative: /a/b/c/d/e.txt
+			//    path to use as base for relative: /a/b/f/
+			//
+			// This loop will start at the left, and remove directories
+			// until we get a mismatch or run off the end of one of them.
+			// In this example, the result will be:
+			//    c/d/e.txt
+			//    f
+			//
+			// For every part left over in the base path, we prepend a ".."
+			// to the relative to get the final path:
+			//   ../c/d/e.txt
+			while(thatParts.length > 0)
+			{
+				if (thisParts.length == 0)
+				{
+					// we matched all there is to match, we are done.
+					// This is the case where "this" object is a parent
+					// path of the given URI.  eg:
+					//   this.path = /a/b/				(thisParts)
+					//   base.path = /a/b/c/d/e/		(thatParts)
+					break;
+				}
+		
+				thisPart = thisParts[0];
+				thatPart = thatParts[0];
+		
+				if (compareStr(thisPart, thatPart, caseSensitive))
+				{
+					thisParts.shift();
+					thatParts.shift();
+				}
+				else
+					break;
+			}
+		
+			// If there are any path info left from the base URI, that means
+			// **this** object is above the given URI in the file tree.  For
+			// each part left over in the given URI, we need to move up one
+			// directory to get where we are.
+			var dotdot:String = "..";
+			for (i = 0; i < thatParts.length; i++)
+			{
+				finalParts.push(dotdot);
+			}
+		
+			// Append the parts of this URI to any dot-dot's we have
+			finalParts = finalParts.concat(thisParts);
+		
+			// Join the parts back into a path
+			finalPath = joinPath(finalParts, false /* not absolute */, isDir);
+		
+			if (finalPath.length == 0)
+			{
+				// The two URI's are exactly the same.  The proper relative
+				// path is:
+				finalPath = "./";
+			}
+		
+			// Set the parts of the URI, preserving the original query and
+			// fragment parts.
+			setParts("", "", "", finalPath, queryStr, fragmentStr);
+		
+			return true;
+		}
+		
+		/**
+		 * Given a string, convert it to a URI.  The string could be a
+		 * full URI that is improperly escaped, a malformed URI (e.g.
+		 * missing a protocol like "www.something.com"), a relative URI,
+		 * or any variation there of.
+		 * 
+		 * <p>The intention of this function is to take anything that a
+		 * user might manually enter as a URI/URL and try to determine what
+		 * they mean.  This function differs from the URI constructor in
+		 * that it makes some assumptions to make it easy to import user
+		 * entered URI data.</p>
+		 * 
+		 * <p>This function is intended to be a helper function.
+		 * It is not all-knowning and will probably make mistakes
+		 * when attempting to parse a string of unknown origin.  If
+		 * your applicaiton is receiving input from the user, your
+		 * application should already have a good idea what the user
+		 * should  be entering, and your application should be
+		 * pre-processing the user's input to make sure it is well formed
+		 * before passing it to this function.</p>
+		 * 
+		 * <p>It is assumed that the string given to this function is
+		 * something the user may have manually entered.  Given this,
+		 * the URI string is probably unescaped or improperly escaped.
+		 * This function will attempt to properly escape the URI by
+		 * using forceEscape().  The result is that a toString() call
+		 * on a URI that was created from unknownToURI() may not match
+		 * the input string due to the difference in escaping.</p>
+		 *
+		 * @param unknown	a potental URI string that should be parsed
+		 * and loaded into this object.
+		 * @param defaultScheme	if it is determined that the passed string
+		 * looks like a URI, but it is missing the scheme part, this
+		 * string will be used as the missing scheme.
+		 * 
+		 * @return	true if the given string was successfully parsed into
+		 * a valid URI object, false otherwise.
+		 */
+		public function unknownToURI(unknown:String, defaultScheme:String = "http") : Boolean
+		{
+			var temp:String;
+			
+			if (unknown.length == 0)
+			{
+				this.initialize();
+				return false;
+			}
+			
+			// Some users love the backslash key.  Fix it.
+			unknown = unknown.replace(/\\/g, "/");
+			
+			// Check for any obviously missing scheme.
+			if (unknown.length >= 2)
+			{
+				temp = unknown.substr(0, 2);
+				if (temp == "//")
+					unknown = defaultScheme + ":" + unknown;
+			}
+			
+			if (unknown.length >= 3)
+			{
+				temp = unknown.substr(0, 3);
+				if (temp == "://")
+					unknown = defaultScheme + unknown;
+			}
+
+			// Try parsing it as a normal URI
+			var uri:URI = new URI(unknown);
+		
+			if (uri.isHierarchical() == false)
+			{
+				if (uri.scheme == UNKNOWN_SCHEME)
+				{
+					this.initialize();
+					return false;
+				}
+		
+				// It's a non-hierarchical URI
+				copyURI(uri);
+				forceEscape();
+				return true;
+			}
+			else if ((uri.scheme != UNKNOWN_SCHEME) &&
+				(uri.scheme.length > 0))
+			{
+				if ( (uri.authority.length > 0) ||
+					(uri.scheme == "file") )
+				{
+					// file://... URI
+					copyURI(uri);
+					forceEscape();  // ensure proper escaping
+					return true;
+				}
+				else if (uri.authority.length == 0 && uri.path.length == 0)
+				{
+					// It's is an incomplete URI (eg "http://")
+					
+					setParts(uri.scheme, "", "", "", "", "");
+					return false;
+				}
+			}
+			else
+			{
+				// Possible relative URI.  We can only detect relative URI's
+				// that start with "." or "..".  If it starts with something
+				// else, the parsing is ambiguous.
+				var path:String = uri.path;
+		
+				if (path == ".." || path == "." || 
+					(path.length >= 3 && path.substr(0, 3) == "../") ||
+					(path.length >= 2 && path.substr(0, 2) == "./") )
+				{
+					// This is a relative URI.
+					copyURI(uri);
+					forceEscape();
+					return true;
+				}
+			}
+		
+			// Ok, it looks like we are just a normal URI missing the scheme.  Tack
+			// on the scheme.
+			uri = new URI(defaultScheme + "://" + unknown);
+		
+			// Check to see if we are good now
+			if (uri.scheme.length > 0 && uri.authority.length > 0)
+			{
+				// It was just missing the scheme.
+				copyURI(uri);
+				forceEscape();  // Make sure we are properly encoded.
+				return true;
+			}
+		
+			// don't know what this is
+			this.initialize();
+			return false;
+		}
+		
+	} // end URI class
+} // end package