diff --git a/Assets/FlashTools/Tools.meta b/Assets/FlashTools/Tools.meta
new file mode 100644
index 0000000..318fe68
--- /dev/null
+++ b/Assets/FlashTools/Tools.meta
@@ -0,0 +1,9 @@
+fileFormatVersion: 2
+guid: 9d6c6f391ae9649bcb55fccdf5549d3c
+folderAsset: yes
+timeCreated: 1472571733
+licenseType: Free
+DefaultImporter:
+  userData: 
+  assetBundleName: 
+  assetBundleVariant: 
diff --git a/Tools/FlashExport.jsfl b/Assets/FlashTools/Tools/FlashExport.jsfl
similarity index 100%
rename from Tools/FlashExport.jsfl
rename to Assets/FlashTools/Tools/FlashExport.jsfl
diff --git a/Assets/FlashTools/Tools/FlashExport.jsfl.meta b/Assets/FlashTools/Tools/FlashExport.jsfl.meta
new file mode 100644
index 0000000..c742675
--- /dev/null
+++ b/Assets/FlashTools/Tools/FlashExport.jsfl.meta
@@ -0,0 +1,8 @@
+fileFormatVersion: 2
+guid: e96e8ffe2177046b7960bd9996721ae6
+timeCreated: 1472571733
+licenseType: Free
+DefaultImporter:
+  userData: 
+  assetBundleName: 
+  assetBundleVariant: 
diff --git a/Tools/FlashExport2.jsfl b/Tools/FlashExport2.jsfl
deleted file mode 100644
index fbaa1cd..0000000
--- a/Tools/FlashExport2.jsfl
+++ /dev/null
@@ -1,1095 +0,0 @@
-// ----------------------------------------------------------------------------
-//
-// JS core
-//
-// ----------------------------------------------------------------------------
-
-if (!String.prototype.format) {
-	String.prototype.format = function () {
-		var args = arguments;
-		return this.replace(/{(\d+)}/g, function (match, number) {
-			return typeof args[number] != 'undefined' ? args[number] : match;
-		});
-	};
-}
-
-if (!Function.prototype.bind) {
-	Function.prototype.bind = function (oThis) {
-		if (typeof this !== 'function') {
-			throw new TypeError('Function.prototype.bind - what is trying to be bound is not callable');
-		}
-		var aArgs = Array.prototype.slice.call(arguments, 1);
-		var fToBind = this;
-		var fNOP = function () {};
-		var fBound = function () {
-			return fToBind.apply(this instanceof fNOP && oThis ? this : oThis,
-				aArgs.concat(Array.prototype.slice.call(arguments)));
-		};
-		fNOP.prototype = this.prototype;
-		fBound.prototype = new fNOP();
-		return fBound;
-	};
-}
-
-if (!Array.prototype.find) {
-	Array.prototype.find = function (predicate) {
-		if (this === null) {
-			throw new TypeError('Array.prototype.find called on null or undefined');
-		}
-		if (typeof predicate !== 'function') {
-			throw new TypeError('predicate must be a function');
-		}
-		var list = Object(this);
-		var length = list.length >>> 0;
-		var thisArg = arguments[1];
-		var value;
-		for (var i = 0; i < length; i++) {
-			value = list[i];
-			if (predicate.call(thisArg, value, i, list)) {
-				return value;
-			}
-		}
-		return undefined;
-	};
-}
-
-if (typeof Object.create != 'function') {
-	Object.create = (function () {
-		function Temp() {}
-		var hasOwn = Object.prototype.hasOwnProperty;
-		return function (O) {
-			if (typeof O != 'object') {
-				throw TypeError('Object prototype may only be an Object or null');
-			}
-			Temp.prototype = O;
-			var obj = new Temp();
-			Temp.prototype = null;
-			if (arguments.length > 1) {
-				var Properties = Object(arguments[1]);
-				for (var prop in Properties) {
-					if (hasOwn.call(Properties, prop)) {
-						obj[prop] = Properties[prop];
-					}
-				}
-			}
-			return obj;
-		};
-	})();
-}
-
-(function () {
-
-	"use strict";
-
-	// ----------------------------------------------------------------------------
-	//
-	// ft
-	//
-	// ----------------------------------------------------------------------------
-
-	var ft = {};
-
-	ft.trace = function () {
-		fl.outputPanel.trace(
-			Array.prototype.join.call(arguments, " "));
-	};
-
-	ft.trace_fmt = function (format) {
-		var args = Array.prototype.slice.call(arguments, 1);
-		ft.trace(format.format.apply(format, args));
-	};
-
-	ft.clear_output = function () {
-		fl.outputPanel.clear();
-	};
-
-	ft.assert = function (expr, format) {
-		if (!expr) {
-			if (format === undefined) {
-				throw "!!!Assert!!!";
-			} else {
-				var args = Array.prototype.slice.call(arguments, 2);
-				throw "!!!Assert!!! " + format.format.apply(format, args);
-			}
-		}
-	};
-
-	ft.type_assert = function (item, type) {
-		var type_is_string = (typeof type === 'string');
-		ft.assert(
-			(type_is_string && typeof item === type) ||
-			(!type_is_string && item instanceof type),
-			"Type error: {0} != {1}",
-			typeof item,
-			type_is_string ? type : type.constructor.name);
-	};
-
-	ft.type_assert_if_defined = function (item, type) {
-		if (item !== undefined) {
-			ft.type_assert(item, type);
-		}
-	};
-
-	ft.escape_path = function (path) {
-		ft.type_assert(path, 'string');
-		return path.replace(/ /g, '%20');
-	};
-
-	ft.escape_string = function (str) {
-		ft.type_assert(str, 'string');
-		return str
-			.replace(/\&/g, '&amp;')
-			.replace(/\"/g, '&quot;')
-			.replace(/\'/g, '&apos;')
-			.replace(/</g, '&lt;')
-			.replace(/>/g, '&gt;');
-	};
-
-	ft.combine_path = function (lhs, rhs) {
-		ft.type_assert(lhs, 'string');
-		ft.type_assert(rhs, 'string');
-		return ft.escape_path(lhs) + ft.escape_path(rhs);
-	};
-	
-	ft.hex_str_to_color32 = function (hstr) {
-		ft.type_assert(hstr, 'string');
-		ft.assert(hstr.length == 7, "incorrect hex_str");
-		var result = [];
-		var hex_digit = ['0','1','2','3','4','5','6','7','8','9','A','B','C','D','E','F'];
-		for (var i = 1; i < hstr.length; i += 2) {
-			result.push(
-				hex_digit.indexOf(hstr[i + 0].toUpperCase()) * 16.0 +
-				hex_digit.indexOf(hstr[i + 1].toUpperCase())
-			);
-		}
-		return result;
-	};
-	
-	ft.array_filter = function (arr, filter) {
-		ft.type_assert(arr, Array);
-		ft.type_assert(filter, Function);
-		var new_arr = [];
-		for (var index = 0; index < arr.length; ++index) {
-			var value = arr[index];
-			if ( filter(value, index) ) {
-				new_arr.push(value);
-			}
-		}
-		return new_arr;
-	};
-	
-	ft.array_foreach = function (arr, func, filter) {
-		ft.type_assert(arr, Array);
-		ft.type_assert(func, Function);
-		ft.type_assert_if_defined(filter, Function);
-		for (var index = 0; index < arr.length; ++index) {
-			var value = arr[index];
-			if (filter === undefined || filter(value, index)) {
-				func(value, index);
-			}
-		}
-	};
-	
-	ft.array_reverse_foreach = function (arr, func, filter) {
-		ft.type_assert(arr, Array);
-		ft.type_assert(func, Function);
-		ft.type_assert_if_defined(filter, Function);
-		for (var index = arr.length - 1; index >= 0; --index) {
-			var value = arr[index];
-			if (filter === undefined || filter(value, index)) {
-				func(value, index);
-			}
-		}
-	};
-
-	ft.object_foreach = function (obj, func, filter) {
-		ft.type_assert(obj, 'object');
-		ft.type_assert(func, Function);
-		ft.type_assert_if_defined(filter, Function);
-		for (var key in obj) {
-			if (obj.hasOwnProperty(key)) {
-				var value = obj[key];
-				if (filter === undefined || filter(key, value)) {
-					func(key, value);
-				}
-			}
-		}
-	};
-
-	// ----------------------------------------------------------------------------
-	//
-	// UniqueIds
-	//
-	// ----------------------------------------------------------------------------
-
-	var UniqueIds = function () {
-		this.clear();
-	};
-
-	UniqueIds.prototype.clear = function () {
-		this.stringIds    = Object.create(null);
-		this.lastStringId = 0;
-	};
-
-	UniqueIds.prototype.get_string_id = function (str) {
-		ft.type_assert(str, 'string');
-		if (this.stringIds.hasOwnProperty(str)) {
-			return this.stringIds[str];
-		} else {
-			this.stringIds[str] = ++this.lastStringId;
-			return this.lastStringId;
-		}
-	};
-
-	UniqueIds.prototype.export = function (xml_node) {
-		ft.type_assert(xml_node, XmlNode);
-		var strings_node = xml_node.child("strings");
-		ft.object_foreach(this.stringIds, function (key, value) {
-			strings_node.child("string")
-				.attr("id", value)
-				.attr("str", ft.escape_string(key));
-		});
-	};
-
-	// ----------------------------------------------------------------------------
-	//
-	// XmlNode
-	//
-	// ----------------------------------------------------------------------------
-
-	var XmlNode = function (node_name, node_parent) {
-		ft.type_assert(node_name, 'string');
-		ft.type_assert_if_defined(node_parent, XmlNode);
-		this.name     = node_name;
-		this.parent   = node_parent;
-		this.attrs    = [];
-		this.children = [];
-	};
-
-	XmlNode.prototype.attr = function (attr_name, attr_value) {
-		ft.type_assert(attr_name, 'string');
-		attr_value = ft.escape_string(attr_value.toString());
-		var attr = this.attrs.find(function (attr) {
-			return attr.name == attr_name;
-		});
-		if (attr) {
-			attr.value = attr_value;
-		} else {
-			this.attrs.push({
-				name: attr_name,
-				value: attr_value
-			});
-		}
-		return this;
-	};
-
-	XmlNode.prototype.child = function (child_name) {
-		ft.type_assert(child_name, 'string');
-		var child = new XmlNode(child_name, this);
-		this.children.push(child);
-		return child;
-	};
-
-	XmlNode.prototype.parent = function () {
-		ft.assert(this.parent !== undefined, "xml node parent is undefined");
-		return this.parent;
-	};
-
-	XmlNode.prototype.content = function (indent) {
-		indent = indent || "";
-		ft.type_assert(indent, 'string');
-		var str = '{0}<{1}'.format(indent, this.name);
-		ft.array_foreach(this.attrs, function (attr) {
-			str += ' {0}="{1}"'.format(attr.name, attr.value);
-		});
-		if (this.children.length > 0) {
-			str += ">\n";
-			ft.array_foreach(this.children, function (child) {
-				str += child.content(indent + "\t") + "\n";
-			});
-			return str + "{0}</{1}>".format(indent, this.name);
-		} else {
-			return str + "/>";
-		}
-	};
-
-	XmlNode.prototype.save = function (xml_path) {
-		if (!FLfile.write(xml_path, this.content())) {
-			throw "Can't save xml to {0}!".format(xml_path);
-		}
-	};
-	
-	// ----------------------------------------------------------------------------
-	//
-	// BitmapAsset
-	//
-	// ----------------------------------------------------------------------------
-
-	var BitmapAsset = function (item, unique_ids) {
-		ft.type_assert(item, BitmapItem);
-		ft.type_assert(unique_ids, UniqueIds);
-		this.item      = item;
-		this.uniqueIds = unique_ids;
-	};
-
-	BitmapAsset.prototype.trace = function (indent) {
-		indent = indent || "";
-		ft.type_assert(indent, 'string');
-		ft.trace_fmt("{0}-= BitmapAsset =-", indent);
-		ft.trace_fmt("{0}-Id   : {1}", indent, this.get_id());
-		ft.trace_fmt("{0}-Name : {1}", indent, this.get_name());
-	};
-
-	BitmapAsset.prototype.get_id = function () {
-		return this.uniqueIds.get_string_id(this.get_name());
-	};
-
-	BitmapAsset.prototype.get_name = function () {
-		return this.item.name;
-	};
-
-	BitmapAsset.prototype.get_export_filename = function () {
-		return "{0}.png".format(this.get_id());
-	};
-
-	BitmapAsset.prototype.get_export_fullfilename = function (export_folder) {
-		ft.type_assert(export_folder, 'string');
-		return ft.combine_path(
-			export_folder,
-			this.get_export_filename());
-	};
-
-	BitmapAsset.prototype.export = function (export_folder, xml_node) {
-		ft.type_assert(export_folder, 'string');
-		ft.type_assert(xml_node, XmlNode);
-		this.export_content(export_folder);
-		this.export_description(xml_node);
-	};
-
-	BitmapAsset.prototype.export_content = function (export_folder) {
-		ft.type_assert(export_folder, 'string');
-		this.item.compressionType = "lossless";
-		var fullfilename = this.get_export_fullfilename(export_folder);
-		if (!this.item.exportToFile(fullfilename, 100)) {
-			throw "Can't export bitmap ({0})!"
-				.format(fullfilename);
-		}
-	};
-
-	BitmapAsset.prototype.export_description = function (xml_node) {
-		ft.type_assert(xml_node, XmlNode);
-		xml_node.child("bitmap")
-			.attr("id", this.get_id());
-	};
-
-	// ----------------------------------------------------------------------------
-	//
-	// SymbolAsset
-	//
-	// ----------------------------------------------------------------------------
-
-	var SymbolAsset = function (item, unique_ids) {
-		ft.type_assert(item, SymbolItem);
-		ft.type_assert(unique_ids, UniqueIds);
-		this.item      = item;
-		this.uniqueIds = unique_ids;
-	};
-
-	SymbolAsset.prototype.trace = function (indent) {
-		indent = indent || "";
-		ft.type_assert(indent, 'string');
-		ft.trace_fmt("{0}-= SymbolAsset =-", indent);
-		ft.trace_fmt("{0}-Id   : {1}"      , indent, this.get_id());
-		ft.trace_fmt("{0}-Name : {1}"      , indent, this.get_name());
-	};
-
-	SymbolAsset.prototype.get_id = function () {
-		return this.uniqueIds.get_string_id(this.get_name());
-	};
-
-	SymbolAsset.prototype.get_name = function () {
-		return this.item.name;
-	};
-	
-	SymbolAsset.prototype.convert = function (document) {
-		ft.type_assert(document, Document);
-		new TimelineInst(this.item.timeline, this.uniqueIds)
-			.convert(document);
-	};
-
-	SymbolAsset.prototype.prepare = function (document) {
-		ft.type_assert(document, Document);
-		new TimelineInst(this.item.timeline, this.uniqueIds)
-			.prepare(document);
-	};
-
-	SymbolAsset.prototype.export = function (xml_node) {
-		ft.type_assert(xml_node, XmlNode);
-		var symbol_node = xml_node.child("symbol")
-			.attr("id", this.get_id());
-		new TimelineInst(this.item.timeline, this.uniqueIds)
-			.export_description(symbol_node);
-	};
-
-	// ----------------------------------------------------------------------------
-	//
-	// LibraryInst
-	//
-	// ----------------------------------------------------------------------------
-
-	var LibraryInst = function (library, unique_ids) {
-		ft.type_assert(library, Library);
-		ft.type_assert(unique_ids, UniqueIds);
-		this.library   = library;
-		this.uniqueIds = unique_ids;
-	};
-
-	LibraryInst.prototype.is_folder_item = function (item) {
-		ft.type_assert(item, LibraryItem);
-		return item.itemType == "folder";
-	};
-
-	LibraryInst.prototype.is_bitmap_item = function (item) {
-		ft.type_assert(item, LibraryItem);
-		return item.itemType == "bitmap";
-	};
-
-	LibraryInst.prototype.is_symbol_item = function (item) {
-		ft.type_assert(item, LibraryItem);
-		return item.itemType == "graphic" || item.itemType == "movie clip";
-	};
-
-	LibraryInst.prototype.for_each_by_items = function (func, filter) {
-		ft.type_assert(func, Function);
-		ft.type_assert_if_defined(filter, Function);
-		ft.array_foreach(this.library.items, func, filter);
-	};
-	
-	LibraryInst.prototype.convert = function (document) {
-		ft.type_assert(document, Document);
-		this.for_each_by_items(function (item) {
-			if ( this.library.editItem(item.name) ) {
-				ft.trace_fmt("Convert: {0}", item.name);
-				new SymbolAsset(item, this.uniqueIds)
-					.convert(document);
-				document.exitEditMode();
-			}
-		}.bind(this), this.is_symbol_item.bind(this));
-	};
-
-	LibraryInst.prototype.prepare = function (document) {
-		ft.type_assert(document, Document);
-		this.for_each_by_items(function (item) {
-			if ( this.library.editItem(item.name) ) {
-				ft.trace_fmt("Prepare: {0}", item.name);
-				new SymbolAsset(item, this.uniqueIds)
-					.prepare(document);
-				document.exitEditMode();
-			}
-		}.bind(this), this.is_symbol_item.bind(this));
-	};
-
-	LibraryInst.prototype.export = function (export_folder, xml_node) {
-		ft.type_assert(export_folder, 'string');
-		ft.type_assert(xml_node, XmlNode);
-		this.for_each_by_items(function (item) {
-			if (this.is_bitmap_item(item)) {
-				new BitmapAsset(item, this.uniqueIds)
-					.export(export_folder, xml_node);
-			} else if (this.is_symbol_item(item)) {
-				new SymbolAsset(item, this.uniqueIds)
-					.export(xml_node);
-			} else {
-				throw "Unsupported library item type ({0})!"
-					.format(item.itemType);
-			}
-		}.bind(this), function (item) {
-			return !this.is_folder_item(item);
-		}.bind(this));
-	};
-
-	// ----------------------------------------------------------------------------
-	//
-	// TimelineInst
-	//
-	// ----------------------------------------------------------------------------
-
-	var TimelineInst = function (timeline, unique_ids) {
-		ft.type_assert(timeline, Timeline);
-		ft.type_assert(unique_ids, UniqueIds);
-		this.timeline  = timeline;
-		this.uniqueIds = unique_ids;
-	};
-
-	TimelineInst.prototype.trace = function (indent) {
-		indent = indent || "";
-		ft.type_assert(indent, 'string');
-		ft.trace_fmt("{0}-= TimelineInst =-", indent);
-		ft.trace_fmt("{0}-Layers : {1}", indent, this.timeline.layerCount);
-		ft.trace_fmt("{0}-Frames : {1}", indent, this.timeline.frameCount);
-	};
-	
-	TimelineInst.prototype.remove_empty_layers = function () {
-		var layers = this.timeline.layers;
-		for ( var i = layers.length - 1; i >= 0; --i ) {
-			var is_empty = new LayerInst(layers[i], this.uniqueIds).is_empty();
-			if ( is_empty ) {
-				this.timeline.deleteLayer(i);
-				layers = this.timeline.layers;
-			}
-		}
-	};
-	
-	TimelineInst.prototype.convert = function (document) {
-		ft.type_assert(document, Document);
-		this.remove_empty_layers();
-		if ( this.timeline.layers.length > 0 && this.timeline.frameCount > 1 ) {
-			this.timeline.selectAllFrames();
-			this.timeline.convertToKeyframes();
-		}
-		ft.array_reverse_foreach(this.timeline.layers, function(layer, index) {
-			this.timeline.setSelectedLayers(index);
-			new LayerInst(layer, this.uniqueIds)
-				.convert(document, this.timeline);
-		}.bind(this));
-	};
-
-	TimelineInst.prototype.prepare = function (document) {
-		ft.type_assert(document, Document);
-		ft.array_reverse_foreach(this.timeline.layers, function(layer, index) {
-			this.timeline.setSelectedLayers(index);
-			new LayerInst(layer, this.uniqueIds)
-				.prepare(document, this.timeline);
-		}.bind(this));
-	};
-
-	TimelineInst.prototype.export_description = function (xml_node) {
-		ft.type_assert(xml_node, XmlNode);
-		ft.array_reverse_foreach(this.timeline.layers, function(layer) {
-			new LayerInst(layer, this.uniqueIds)
-				.export_description(xml_node);
-		}.bind(this));
-	};
-
-	// ----------------------------------------------------------------------------
-	//
-	// LayerInst
-	//
-	// ----------------------------------------------------------------------------
-
-	var LayerInst = function (layer, unique_ids) {
-		ft.type_assert(layer, Layer);
-		ft.type_assert(unique_ids, UniqueIds);
-		this.layer     = layer;
-		this.uniqueIds = unique_ids;
-	};
-
-	LayerInst.prototype.trace = function (indent) {
-		indent = indent || "";
-		ft.type_assert(indent, 'string');
-		ft.trace_fmt("{0}-= LayerInst =-", indent);
-		ft.trace_fmt("{0}-Id     : {1}"  , indent, this.get_id());
-		ft.trace_fmt("{0}-Name   : {1}"  , indent, this.get_name());
-		ft.trace_fmt("{0}-Frames : {1}"  , indent, this.layer.frameCount);
-	};
-
-	LayerInst.prototype.get_id = function () {
-		return this.uniqueIds.get_string_id(this.get_name());
-	};
-
-	LayerInst.prototype.get_name = function () {
-		return this.layer.name;
-	};
-	
-	LayerInst.prototype.is_empty = function () {
-		if ( !this.layer.visible ) {
-			return true;
-		}
-		if ( this.layer.layerType == "guide" || this.layer.layerType == "mask" || this.layer.layerType == "folder" ) {
-			return false;
-		}
-		var frames = this.layer.frames;
-		for ( var i = 0; i < frames.length; ++i ) {
-			var is_empty = new FrameInst(frames[i], i, this.uniqueIds).is_empty();
-			if ( !is_empty ) {
-				return false;
-			}
-		}
-		return true;
-	};
-
-	LayerInst.prototype.do_in_unlocked = function (func) {
-		ft.type_assert(func, Function);
-		var prev_locked    = this.layer.locked;
-		var prev_visible   = this.layer.visible;
-		this.layer.locked  = false;
-		this.layer.visible = true;
-		func();
-		this.layer.locked  = prev_locked;
-		this.layer.visible = prev_visible;
-	};
-	
-	LayerInst.prototype.convert = function (document, timeline) {
-		ft.type_assert(document, Document);
-		ft.type_assert(timeline, Timeline);
-		this.do_in_unlocked(function() {
-			ft.array_foreach(this.layer.frames, function(frame, index) {
-				frame.convertToFrameByFrameAnimation();
-			}.bind(this));
-			ft.array_foreach(this.layer.frames, function(frame, index) {
-				var inst = new FrameInst(frame, index, this.uniqueIds);
-				if (inst.get_start_frame() == index) {
-					timeline.setSelectedFrames(index, index + 1);
-					inst.convert(document, timeline, this.layer);
-				}
-			}.bind(this));
-		}.bind(this));
-	};
-
-	LayerInst.prototype.prepare = function (document, timeline) {
-		ft.type_assert(document, Document);
-		ft.type_assert(timeline, Timeline);
-		this.do_in_unlocked(function() {
-			ft.array_foreach(this.layer.frames, function(frame, index) {
-				var inst = new FrameInst(frame, index, this.uniqueIds);
-				if (inst.get_start_frame() == index) {
-					timeline.setSelectedFrames(index, index + 1);
-					inst.prepare(document, timeline, this.layer);
-				}
-			}.bind(this));
-		}.bind(this));
-	};
-
-	LayerInst.prototype.export_description = function (xml_node) {
-		ft.type_assert(xml_node, XmlNode);
-		var layer_node = xml_node.child("layer")
-			.attr("id"        , this.get_id())
-			.attr("layer_type", this.layer.layerType);
-		if (this.layer.parentLayer) {
-			var parent_layer = new LayerInst(this.layer.parentLayer, this.uniqueIds);
-			layer_node.attr("parent_layer", parent_layer.get_id());
-		}
-		ft.array_foreach(this.layer.frames, function (frame, index) {
-			var inst = new FrameInst(frame, index, this.uniqueIds);
-			if (inst.get_start_frame() == index) {
-				inst.export_description(layer_node);
-			}
-		}.bind(this));
-	};
-
-	// ----------------------------------------------------------------------------
-	//
-	// FrameInst
-	//
-	// ----------------------------------------------------------------------------
-
-	var FrameInst = function (frame, index, unique_ids) {
-		ft.type_assert(frame, Frame);
-		ft.type_assert(index, 'number');
-		ft.type_assert(unique_ids, UniqueIds);
-		this.frame     = frame;
-		this.index     = index;
-		this.uniqueIds = unique_ids;
-	};
-
-	FrameInst.prototype.trace = function (indent) {
-		indent = indent || "";
-		ft.type_assert(indent, 'string');
-		ft.trace_fmt("{0}-= FrameInst =-", indent);
-		ft.trace_fmt("{0}-Id       : {1}", indent, this.get_id());
-		ft.trace_fmt("{0}-Name     : {1}", indent, this.get_name());
-		ft.trace_fmt("{0}-Elements : {1}", indent, this.frame.elements.length);
-	};
-
-	FrameInst.prototype.get_id = function () {
-		return this.uniqueIds.get_string_id(this.get_name());
-	};
-
-	FrameInst.prototype.get_name = function () {
-		return this.frame.name;
-	};
-
-	FrameInst.prototype.get_index = function () {
-		return this.index;
-	};
-
-	FrameInst.prototype.get_start_frame = function () {
-		return this.frame.startFrame;
-	};
-	
-	FrameInst.prototype.is_empty = function () {
-		return this.frame.elements.length == 0;
-	};
-
-	FrameInst.prototype.is_element_shape = function (element) {
-		return element.elementType == "shape";
-	};
-
-	FrameInst.prototype.is_element_instance = function (element) {
-		return element.elementType == "instance";
-	};
-
-	FrameInst.prototype.is_element_bitmap = function (element) {
-		return this.is_element_instance(element) && element.instanceType == "bitmap";
-	};
-
-	FrameInst.prototype.is_element_symbol = function (element) {
-		return this.is_element_instance(element) && element.instanceType == "symbol";
-	};
-	
-	FrameInst.prototype.convert = function (document, timeline, layer) {
-		ft.type_assert(document, Document);
-		ft.type_assert(timeline, Timeline);
-		ft.type_assert(layer, Layer);
-	};
-
-	FrameInst.prototype.prepare = function (document, timeline, layer) {
-		ft.type_assert(document, Document);
-		ft.type_assert(timeline, Timeline);
-		ft.type_assert(layer, Layer);
-		timeline.currentFrame = this.frame.startFrame;
-		document.selectNone();
-		document.selection = ft.array_filter(
-			this.frame.elements,
-			this.is_element_shape.bind(this));
-		if ( document.selection.length > 0 ) {
-			document.convertSelectionToBitmap();
-			document.arrange("back");
-		}
-	};
-
-	FrameInst.prototype.export_element = function (xml_node, element) {
-		ft.type_assert(xml_node, XmlNode);
-		ft.type_assert(element, Element);
-		if (this.is_element_bitmap(element)) {
-			new BitmapInst(element, this.uniqueIds)
-				.export_description(xml_node);
-		} else if (this.is_element_symbol(element)) {
-			new SymbolInst(element, this.uniqueIds)
-				.export_description(xml_node);
-		} else if (this.is_element_instance(element)) {
-			ft.assert(false,
-				"Unsupported instance type ({0})!",
-				element.instanceType);
-		} else {
-			ft.assert(false,
-				"Unsupported element type ({0})!",
-				element.elementType);
-		}
-	};
-
-	FrameInst.prototype.export_description = function (xml_node) {
-		ft.type_assert(xml_node, XmlNode);
-		var frame_node = xml_node.child("frame")
-			.attr("id", this.get_id());
-		ft.array_foreach(this.frame.elements, function (element) {
-			this.export_element(frame_node, element);
-		}.bind(this));
-	};
-
-	// ----------------------------------------------------------------------------
-	//
-	// ElementInst
-	//
-	// ----------------------------------------------------------------------------
-
-	var ElementInst = function (inst, unique_ids) {
-		ft.type_assert(inst, Instance);
-		ft.type_assert(unique_ids, UniqueIds);
-		this.inst      = inst;
-		this.uniqueIds = unique_ids;
-	};
-
-	ElementInst.prototype.trace = function (indent) {
-		indent = indent || "";
-		ft.type_assert(indent, 'string');
-		ft.trace_fmt("{0}-= ElementInst =-", indent);
-		ft.trace_fmt("{0}-Id   : {1}", indent, this.get_id());
-		ft.trace_fmt("{0}-Name : {1}", indent, this.get_name());
-	};
-
-	ElementInst.prototype.get_id = function () {
-		return this.uniqueIds.get_string_id(this.get_name());
-	};
-
-	ElementInst.prototype.get_name = function () {
-		return this.inst.name;
-	};
-
-	ElementInst.prototype.export_description = function (xml_node) {
-		ft.type_assert(xml_node, XmlNode);
-		return xml_node.child("element")
-			.attr("id"    , this.get_id())
-			.attr("matrix", "{0};{1};{2};{3};{4};{5}".format(
-				this.inst.matrix.a, this.inst.matrix.b,
-				this.inst.matrix.c, this.inst.matrix.d,
-				this.inst.matrix.tx, this.inst.matrix.ty));
-	};
-
-	// ----------------------------------------------------------------------------
-	//
-	// BitmapInst
-	//
-	// ----------------------------------------------------------------------------
-
-	var BitmapInst = function (inst, unique_ids) {
-		ElementInst.call(this, inst, unique_ids);
-	};
-
-	BitmapInst.prototype = Object.create(ElementInst.prototype);
-
-	BitmapInst.prototype.export_description = function (xml_node) {
-		ft.type_assert(xml_node, XmlNode);
-		ElementInst.prototype.export_description.call(this, xml_node)
-			.child("instance")
-			.attr("type" , "bitmap")
-			.attr("asset", this.uniqueIds.get_string_id(this.inst.libraryItem.name));
-	};
-
-	// ----------------------------------------------------------------------------
-	//
-	// SymbolInst
-	//
-	// ----------------------------------------------------------------------------
-
-	var SymbolInst = function (inst, unique_ids) {
-		ElementInst.call(this, inst, unique_ids);
-	};
-
-	SymbolInst.prototype = Object.create(ElementInst.prototype);
-	
-	SymbolInst.prototype.get_symbol_type = function () {
-		var symbol_type = this.inst.symbolType;
-		if ( symbol_type == "movie clip" ) {
-			return "movieclip";
-		} else if ( symbol_type == "graphic" ) {
-			return "graphic";
-		} else {
-			throw "Unsupported symbol type ({0})!"
-				.format(symbol_type);
-		}
-	};
-	
-	SymbolInst.prototype.get_first_frame = function () {
-		return this.inst.firstFrame !== undefined ? this.inst.firstFrame : 0;
-	};
-	
-	SymbolInst.prototype.get_looping_mode = function () {
-		var looping_type = this.inst.loop !== undefined ? this.inst.loop : "single frame";
-		if ( looping_type == "loop" ) {
-			return "loop";
-		} else if ( looping_type == "play once" ) {
-			return "playonce";
-		} else if ( looping_type == "single frame" ) {
-			return "singleframe";
-		} else {
-			throw "Unsupported looping type ({0})!"
-				.format(looping_type);
-		}
-	};
-
-	SymbolInst.prototype.export_description = function (xml_node) {
-		ft.type_assert(xml_node, XmlNode);
-		var instance_node = ElementInst.prototype.export_description.call(this, xml_node)
-			.child("instance")
-			.attr("type"        , "symbol")
-			.attr("asset"       , this.uniqueIds.get_string_id(this.inst.libraryItem.name))
-			.attr("visible"     , this.inst.visible)
-			.attr("blend_mode"  , this.inst.blendMode)
-			.attr("symbol_type" , this.get_symbol_type())
-			.attr("first_frame" , this.get_first_frame())
-			.attr("looping_mode", this.get_looping_mode());
-		if (this.inst.colorMode !== "none") {
-			var color_effect_node = instance_node.child("color_effect");
-			if (this.inst.colorMode == "brightness") {
-				var brightness = this.inst.brightness / 100.0;
-				color_effect_node.attr("transform", "{0};{1};{2};{3};{4};{5};{6};{7}".format(
-					1 - Math.abs(brightness),
-					1 - Math.abs(brightness),
-					1 - Math.abs(brightness),
-					1,
-					brightness < 0 ? 0 : brightness,
-					brightness < 0 ? 0 : brightness,
-					brightness < 0 ? 0 : brightness,
-					0));
-			} else if (this.inst.colorMode == "tint") {
-				var tint_color   = ft.hex_str_to_color32(this.inst.tintColor);
-				var tint_percent = this.inst.tintPercent / 100.0;
-				color_effect_node.attr("transform", "{0};{1};{2};{3};{4};{5};{6};{7}".format(
-					1 - tint_percent,
-					1 - tint_percent,
-					1 - tint_percent,
-					1,
-					tint_color[0] / 255.0 * tint_percent,
-					tint_color[1] / 255.0 * tint_percent,
-					tint_color[2] / 255.0 * tint_percent,
-					0));
-			} else if (this.inst.colorMode == "alpha") {
-				var alpha = this.inst.colorAlphaPercent / 100.0;
-				color_effect_node.attr("transform", "{0};{1};{2};{3};{4};{5};{6};{7}".format(
-					1,
-					1,
-					1,
-					alpha,
-					0,
-					0,
-					0,
-					0));
-			} else if (this.inst.colorMode == "advanced") {
-				color_effect_node.attr("transform", "{0};{1};{2};{3};{4};{5};{6};{7}".format(
-					this.inst.colorRedPercent   / 100.0,
-					this.inst.colorGreenPercent / 100.0,
-					this.inst.colorBluePercent  / 100.0,
-					this.inst.colorAlphaPercent / 100.0,
-					this.inst.colorRedAmount    / 255.0,
-					this.inst.colorGreenAmount  / 255.0,
-					this.inst.colorBlueAmount   / 255.0,
-					this.inst.colorAlphaAmount  / 255.0));
-			} else {
-				ft.assert(false,
-					"Unsupported color mode ({0})!",
-					this.inst.colorMode);
-			}
-		}
-	};
-
-	// ----------------------------------------------------------------------------
-	//
-	// Exporter
-	//
-	// ----------------------------------------------------------------------------
-
-	var Exporter = function (document) {
-		ft.type_assert(document, Document);
-		this.document     = document;
-		this.uniqueIds    = new UniqueIds();
-		this.documentPath = ft.escape_path(this.document.pathURI);
-	};
-
-	Exporter.prototype.trace = function (indent) {
-		indent = indent || "";
-		ft.type_assert(indent, 'string');
-		ft.trace_fmt("{0}-= Exporter =-", indent);
-		ft.trace_fmt("{0}-Document name : {1}", indent, this.get_document_name());
-		ft.trace_fmt("{0}-Document path : {1}", indent, this.get_document_path());
-		ft.trace_fmt("{0}-Export folter : {1}", indent, this.get_export_folder());
-		ft.trace_fmt("{0}-Export path   : {1}", indent, this.get_export_path());
-	};
-	
-	Exporter.prototype.get_document_name = function () {
-		return this.document.name;
-	};
-
-	Exporter.prototype.get_document_path = function () {
-		return this.documentPath;
-	};
-
-	Exporter.prototype.get_export_folder = function () {
-		return ft.combine_path(
-			this.get_document_path(),
-			"_export/");
-	};
-	
-	Exporter.prototype.get_export_path = function () {
-		return ft.combine_path(
-			this.get_export_folder(),
-			this.get_document_name() + ".fta");
-	};
-
-	Exporter.prototype.export = function () {
-		this.trace();
-		fl.showIdleMessage(false);
-		ft.trace("- Start...");
-		try {
-			this.prepare_folders();
-			this.full_exit_edit_mode();
-			this.delete_unused_items();
-			this.convert_document();
-			this.prepare_document();
-			this.export_document();
-			ft.trace_fmt("- Finish : {0}", this.get_export_folder());
-		} catch (e) {
-			ft.trace_fmt("- Error : {0}", e);
-		}
-		fl.revertDocument(this.document);
-		fl.showIdleMessage(true);
-	};
-
-	Exporter.prototype.prepare_folders = function () {
-		var export_folder = this.get_export_folder();
-		if (FLfile.exists(export_folder)) {
-			if (!FLfile.remove(export_folder)) {
-				throw "Can't remove document export folder ({0})!"
-					.format(export_folder);
-			}
-		}
-		if (!FLfile.createFolder(export_folder)) {
-			throw "Can't create document export folder ({0})!"
-				.format(export_folder);
-		}
-	};
-	
-	Exporter.prototype.full_exit_edit_mode = function () {
-		for (var i = 0; i < 100; ++i) {
-			this.document.exitEditMode();
-		}
-	};
-	
-	Exporter.prototype.delete_unused_items = function() {
-		var unused_items = this.document.library.unusedItems;
-		ft.array_foreach(unused_items, function (item) {
-			ft.trace_fmt("Remove unused item: {0}", item.name);
-			this.document.library.deleteItem(item.name);
-		});
-	};
-	
-	Exporter.prototype.convert_document = function () {
-		new TimelineInst(this.document.getTimeline(), this.uniqueIds)
-			.convert(this.document);
-		new LibraryInst(this.document.library, this.uniqueIds)
-			.convert(this.document);
-	};
-
-	Exporter.prototype.prepare_document = function () {
-		new TimelineInst(this.document.getTimeline(), this.uniqueIds)
-			.prepare(this.document);
-		new LibraryInst(this.document.library, this.uniqueIds)
-			.prepare(this.document);
-	};
-	
-	Exporter.prototype.export_document = function() {
-		var xml_node = new XmlNode("document")
-			.attr("frame_rate", this.document.frameRate);
-		this.export_library(xml_node);
-		this.export_stage(xml_node);
-		this.export_strings(xml_node);
-		xml_node.save(this.get_export_path());
-	};
-
-	Exporter.prototype.export_library = function (xml_node) {
-		var library_node = xml_node.child("library");
-		new LibraryInst(this.document.library, this.uniqueIds)
-			.export(this.get_export_folder(), library_node);
-	};
-
-	Exporter.prototype.export_stage = function (xml_node) {
-		var stage_node = xml_node.child("stage");
-		new TimelineInst(this.document.getTimeline(), this.uniqueIds)
-			.export_description(stage_node);
-	};
-
-	Exporter.prototype.export_strings = function (xml_node) {
-		this.uniqueIds.export(xml_node);
-	};
-
-	// ------------------------------------
-	// Main
-	// ------------------------------------
-
-	(function () {
-		ft.clear_output();
-		ft.array_foreach(fl.documents, function (document) {
-			new Exporter(document).export();
-		});
-	})();
-})();