[haxe] Clean-up of documentation, remove HTML tags

spine-haxe/spine-haxe/spine/Bone.hx

@@ -30,7 +30,7 @@
 package spine;
 
 /** Stores a bone's current pose.
- * <p>
+ *
  * A bone has a local transform which is used to compute its world transform. A bone also has an applied transform, which is a
  * local transform that can be applied to compute the world transform. The local transform and applied transform may differ if a
  * constraint or application code modifies the world transform after it was computed from the local transform. */
@@ -137,7 +137,7 @@ class Bone implements Updatable {
 	}
 
 	/** Computes the world transform using the parent bone and this bone's local transform.
-	 * <p>
+	 *
 	 * See updateWorldTransformWith(). */
 	public function updateWorldTransform():Void {
 		updateWorldTransformWith(x, y, rotation, scaleX, scaleY, shearX, shearY);
@@ -145,9 +145,9 @@ class Bone implements Updatable {
 
 	/** Computes the world transform using the parent bone and the specified local transform. The applied transform is set to the
 	 * specified local transform. Child bones are not updated.
-	 * <p>
-	 * See <a href="https://esotericsoftware.com/spine-runtime-skeletons#World-transforms">World transforms</a> in the Spine
-	 * Runtimes Guide. */
+	 *
+	 * @see https://esotericsoftware.com/spine-runtime-skeletons#World-transforms World transforms in the Spine Runtimes Guide
+	 */
 	public function updateWorldTransformWith(x:Float, y:Float, rotation:Float, scaleX:Float, scaleY:Float, shearX:Float, shearY:Float):Void {
 		ax = x;
 		ay = y;
@@ -283,11 +283,11 @@ class Bone implements Updatable {
 	}
 
 	/** Computes the applied transform values from the world transform.
-	 * <p>
+	 *
 	 * If the world transform is modified (by a constraint, rotateWorld(), etc) then this method should be called so
 	 * the applied transform matches the world transform. The applied transform may be needed by other code (eg to apply another
 	 * constraint).
-	 * <p>
+	 *
 	 * Some information is ambiguous in the world transform, such as -1,-1 scale versus 180 rotation. The applied transform after
 	 * calling this method is equivalent to the local transform used to compute the world transform, but may not be identical. */
 	public function updateAppliedTransform():Void {
@@ -446,7 +446,7 @@ class Bone implements Updatable {
 	}
 
 	/** Rotates the world transform the specified amount.
-	 * <p>
+	 *
 	 * After changes are made to the world transform, updateAppliedTransform() should be called and
 	 * update() will need to be called on any child bones, recursively. */
 	public function rotateWorld(degrees:Float):Void {

spine-haxe/spine-haxe/spine/Event.hx

@@ -34,7 +34,8 @@ package spine;
  * @see spine.Timeline
  * @see spine.Timeline.apply()
  * @see spine.AnimationStateListener.event()
- * @see <a href="https://esotericsoftware.com/spine-events">Events</a> in the Spine User Guide. */
+ * @see https://esotericsoftware.com/spine-events Events in the Spine User Guide
+ */
 class Event {
 	private var _data:EventData;
 

spine-haxe/spine-haxe/spine/EventData.hx

@@ -31,7 +31,9 @@ package spine;
 
 /** Stores the setup pose values for an spine.Event.
  * 
- * See <a href="https://esotericsoftware.com/spine-events">Events</a> in the Spine User Guide. */
+ * 
+ * @see https://esotericsoftware.com/spine-events Events in the Spine User Guide
+ */
 class EventData {
 	private var _name:String;
 

spine-haxe/spine-haxe/spine/IkConstraint.hx

@@ -31,8 +31,8 @@ package spine;
 
 /** Stores the current pose for an IK constraint. An IK constraint adjusts the rotation of 1 or 2 constrained bones so the tip of
  * the last bone is as close to the target bone as possible.
- * <p>
- * See <a href="https://esotericsoftware.com/spine-ik-constraints">IK constraints</a> in the Spine User Guide. */
+ *
+ * @see https://esotericsoftware.com/spine-ik-constraints IK constraints in the Spine User Guide */
 class IkConstraint implements Updatable {
 	private var _data:IkConstraintData;
 
@@ -45,12 +45,12 @@ class IkConstraint implements Updatable {
 	/** For one bone IK, when true and the target is too close, the bone is scaled to reach it. */
 	public var compress:Bool = false;
 	/** When true and the target is out of range, the parent bone is scaled to reach it.
-	 * <p>
+	 *
 	 * For two bone IK: 1) the child bone's local Y translation is set to 0, 2) stretch is not applied if getSoftness() is
 	 * > 0, and 3) if the parent bone has local nonuniform scale, stretch is not applied. */
 	public var stretch:Bool = false;
 	/** A percentage (0-1) that controls the mix between the constrained and unconstrained rotation.
-	 * <p>
+	 *
 	 * For two bone IK: if the parent bone has local nonuniform scale, the child bone's local Y translation is set to 0. */
 	public var mix:Float = 0;
 	/** For two bone IK, the target bone's distance from the maximum reach of the bones where rotation begins to slow. The bones

spine-haxe/spine-haxe/spine/IkConstraintData.hx

@@ -31,7 +31,7 @@ package spine;
 
 /** Stores the setup pose for a spine.IkConstraint.
  * 
- * See <a href="https://esotericsoftware.com/spine-ik-constraints">IK constraints</a> in the Spine User Guide. */
+ * @see https://esotericsoftware.com/spine-ik-constraints IK constraints in the Spine User Guide */
 class IkConstraintData extends ConstraintData {
 	/** The bones that are constrained by this IK constraint. */
 	public var bones:Array<BoneData> = new Array<BoneData>();

spine-haxe/spine-haxe/spine/PathConstraint.hx

@@ -32,9 +32,9 @@ package spine;
 import spine.attachments.PathAttachment;
 
 /** Stores the current pose for a path constraint. A path constraint adjusts the rotation, translation, and scale of the
- * constrained bones so they follow a {@link PathAttachment}.
+ * constrained bones so they follow a PathAttachment.
  *
- * See <a href="https://esotericsoftware.com/spine-path-constraints">Path constraints</a> in the Spine User Guide. */
+ * @see https://esotericsoftware.com/spine-path-constraints Path constraints in the Spine User Guide */
 class PathConstraint implements Updatable {
 	private static inline var NONE:Int = -1;
 	private static inline var BEFORE:Int = -2;

spine-haxe/spine-haxe/spine/PathConstraintData.hx

@@ -31,7 +31,7 @@ package spine;
 
 /** Stores the setup pose for a spine.PathConstraint.
  * 
- * See <a href="https://esotericsoftware.com/spine-path-constraints">Path constraints</a> in the Spine User Guide. */
+ * @see https://esotericsoftware.com/spine-path-constraints Path constraints in the Spine User Guide */
 class PathConstraintData extends ConstraintData {
 	/** The bones that will be modified by this path constraint. */
 	private var _bones:Array<BoneData> = new Array<BoneData>();

spine-haxe/spine-haxe/spine/PhysicsConstraint.hx

@@ -31,7 +31,9 @@ package spine;
 
 /** Stores the current pose for a physics constraint. A physics constraint applies physics to bones.
  * 
- * See <a href="https://esotericsoftware.com/spine-physics-constraints">Physics constraints</a> in the Spine User Guide. */
+ * 
+ * @see https://esotericsoftware.com/spine-physics-constraints Physics constraints in the Spine User Guide
+ */
 class PhysicsConstraint implements Updatable {
 	private var _data:PhysicsConstraintData;
 	private var _bone:Bone = null;

spine-haxe/spine-haxe/spine/PhysicsConstraintData.hx

@@ -29,9 +29,9 @@
 
 package spine;
 
-/** Stores the setup pose for a {@link PhysicsConstraint}.
+/** Stores the setup pose for a PhysicsConstraint.
  * 
- * See <a href="https://esotericsoftware.com/spine-physics-constraints">Physics constraints</a> in the Spine User Guide. */
+ * @see https://esotericsoftware.com/spine-physics-constraints Physics constraints in the Spine User Guide */
 class PhysicsConstraintData extends ConstraintData {
 	/** The bone constrained by this physics constraint. */
 	public var bone:BoneData;

spine-haxe/spine-haxe/spine/PositionMode.hx

@@ -31,9 +31,8 @@ package spine;
 
 /**
  * Controls how the first bone is positioned along the path.
- * <p>
- * See <a href="https://esotericsoftware.com/spine-path-constraints#Position-mode">Position mode</a> in the Spine User
- * Guide.
+ *
+ * @see https://esotericsoftware.com/spine-path-constraints#Position-mode Position mode in the Spine User Guide
  */
 class PositionMode {
 	public static var fixed(default, never):PositionMode = new PositionMode("fixed");

spine-haxe/spine-haxe/spine/RotateMode.hx

@@ -31,7 +31,7 @@ package spine;
 
 /** Controls how bones are rotated, translated, and scaled to match the path.
  * 
- * See <a href="https://esotericsoftware.com/spine-path-constraints#Rotate-mode">Rotate mode</a> in the Spine User Guide. */
+ * @see https://esotericsoftware.com/spine-path-constraints#Rotate-mode Rotate mode in the Spine User Guide */
 class RotateMode {
 	public static var tangent(default, never):RotateMode = new RotateMode("tangent");
 	public static var chain(default, never):RotateMode = new RotateMode("chain");

spine-haxe/spine-haxe/spine/SequenceMode.hx

@@ -30,7 +30,7 @@
 package spine;
 
 /**
- * Defines how a {@link Sequence} is played.
+ * Defines how a Sequence is played.
  */
 class SequenceMode {
 	public static var hold(default, never):SequenceMode = new SequenceMode("hold", 0);

spine-haxe/spine-haxe/spine/Skeleton.hx

@@ -38,9 +38,9 @@ import spine.attachments.PathAttachment;
 import spine.attachments.RegionAttachment;
 
 /** Stores the current pose for a skeleton.
- * <p>
- * See <a href="https://esotericsoftware.com/spine-runtime-architecture#Instance-objects">Instance objects</a> in the Spine
- * Runtimes Guide. */
+ *
+ * @see https://esotericsoftware.com/spine-runtime-architecture#Instance-objects Instance objects in the Spine Runtimes Guide
+ */
 class Skeleton {
 	private static var quadTriangles:Array<Int> = [0, 1, 2, 2, 3, 0];
 	private var _data:SkeletonData;
@@ -66,12 +66,12 @@ class Skeleton {
 	/** The color to tint all the skeleton's attachments. */
 	public var color:Color = new Color(1, 1, 1, 1);
 	/** Scales the entire skeleton on the X axis.
-	 * <p>
+	 *
 	 * Bones that do not inherit scale are still affected by this property. */
 	public var scaleX:Float = 1;
 
 	/** Scales the entire skeleton on the Y axis.
-	 * <p>
+	 *
 	 * Bones that do not inherit scale are still affected by this property. */
 	public var scaleY(get, default):Float = 1;
 	function get_scaleY() {
@@ -79,15 +79,15 @@ class Skeleton {
 	}
 
 	/** Sets the skeleton X position, which is added to the root bone worldX position.
-	 * <p>
+	 *
 	 * Bones that do not inherit translation are still affected by this property. */
 	public var x:Float = 0;
 	/** Sets the skeleton Y position, which is added to the root bone worldY position.
-	 * <p>
+	 *
 	 * Bones that do not inherit translation are still affected by this property. */
 	public var y:Float = 0;
 	/** Returns the skeleton's time. This is used for time-based manipulations, such as spine.PhysicsConstraint.
-	 * <p>
+	 *
 	 * See Skeleton.update(). */
 	public var time:Float = 0;
 
@@ -379,9 +379,9 @@ class Skeleton {
 	}
 
 	/** Updates the world transform for each bone and applies all constraints.
-	 * <p>
-	 * See <a href="https://esotericsoftware.com/spine-runtime-skeletons#World-transforms">World transforms</a> in the Spine
-	 * Runtimes Guide. */
+	 *
+	 * @see https://esotericsoftware.com/spine-runtime-skeletons#World-transforms World transforms in the Spine Runtimes Guide
+	 */
 	public function updateWorldTransform(physics:Physics):Void {
 		if (physics == null) throw new SpineException("physics is undefined");
 		for (bone in bones) {
@@ -401,9 +401,9 @@ class Skeleton {
 
 	/** Temporarily sets the root bone as a child of the specified bone, then updates the world transform for each bone and applies
 	 * all constraints.
-	 * <p>
-	 * See <a href="https://esotericsoftware.com/spine-runtime-skeletons#World-transforms">World transforms</a> in the Spine
-	 * Runtimes Guide. */
+	 *
+	 * @see https://esotericsoftware.com/spine-runtime-skeletons#World-transforms World transforms in the Spine Runtimes Guide
+	 */
 	public function updateWorldTransformWith(physics:Physics, parent:Bone):Void {
 		// Apply the parent bone transform to the root bone. The root bone always inherits scale, rotation and reflection.
 		var rootBone:Bone = rootBone;
@@ -523,7 +523,7 @@ class Skeleton {
 	public var skinName(get, set):String;
 
 	/** Sets a skin by name.
-	 * <p>
+	 *
 	 * See Skeleton.skin. */
 	private function set_skinName(skinName:String):String {
 		var skin:Skin = data.findSkin(skinName);
@@ -547,10 +547,10 @@ class Skeleton {
 
 	/** Sets the skin used to look up attachments before looking in the spine.SkeletonData default skin. If the
 	 * skin is changed, Skeleton.updateCache() is called.
-	 * <p>
+	 *
 	 * Attachments from the new skin are attached if the corresponding attachment from the old skin was attached. If there was no
 	 * old skin, each slot's setup mode attachment is attached from the new skin.
-	 * <p>
+	 *
 	 * After changing the skin, the visible attachments can be reset to those attached in the setup pose by calling
 	 * Skeleton.setSlotsToSetupPose(). Also, often spine.AnimationState.apply() is called before the next time the
 	 * skeleton is rendered to allow any attachment keys in the current animation(s) to hide or show attachments from the new
@@ -581,7 +581,7 @@ class Skeleton {
 
 	/** Finds an attachment by looking in the Skeleton.skin and spine.SkeletonData defaultSkin using the slot name and attachment
 	 * name.
-	 * <p>
+	 *
 	 * See Skeleton.getAttachmentForSlotIndex(). */
 	public function getAttachmentForSlotName(slotName:String, attachmentName:String):Attachment {
 		return getAttachmentForSlotIndex(data.findSlot(slotName).index, attachmentName);
@@ -589,8 +589,9 @@ class Skeleton {
 
 	/** Finds an attachment by looking in the Skeleton.skin and spine.SkeletonData defaultSkin using the slot index and
 	 * attachment name. First the skin is checked and if the attachment was not found, the default skin is checked.
-	 * <p>
-	 * See <a href="https://esotericsoftware.com/spine-runtime-skins">Runtime skins</a> in the Spine Runtimes Guide. */
+	 *
+	 * @see https://esotericsoftware.com/spine-runtime-skins Runtime skins in the Spine Runtimes Guide
+	 */
 	public function getAttachmentForSlotIndex(slotIndex:Int, attachmentName:String):Attachment {
 		if (attachmentName == null)
 			throw new SpineException("attachmentName cannot be null.");

spine-haxe/spine-haxe/spine/SkeletonBinary.hx

@@ -84,10 +84,9 @@ import spine.attachments.VertexAttachment;
 
 /**
  * Loads skeleton data in the Spine binary format.
- * <p>
- * See <a href="https://esotericsoftware.com/spine-binary-format">Spine binary format</a> and
- * <a href="https://esotericsoftware.com/spine-loading-skeleton-data#JSON-and-binary-data">JSON and binary data</a> in the Spine
- * Runtimes Guide.
+ *
+ * @see https://esotericsoftware.com/spine-binary-format Spine binary format
+ * @see https://esotericsoftware.com/spine-loading-skeleton-data#JSON-and-binary-data JSON and binary data in the Spine Runtimes Guide
  */
 class SkeletonBinary {
 	public var attachmentLoader:AttachmentLoader;

spine-haxe/spine-haxe/spine/SkeletonData.hx

@@ -36,8 +36,9 @@ import spine.atlas.TextureAtlas;
 import spine.attachments.AtlasAttachmentLoader;
 
 /** Stores the setup pose and all of the stateless data for a skeleton.
- * <p>
- * See <a href="https://esotericsoftware.com/spine-runtime-architecture#Data-objects">Data objects</a> in the Spine Runtimes
+ *
+ * 
+ * @see https://esotericsoftware.com/spine-runtime-architecture#Data-objects Data objects in the Spine Runtimes
  * Guide. */
 class SkeletonData {
 	/** The skeleton's name, which by default is the name of the skeleton data file when possible, or null when a name hasn't been
@@ -51,8 +52,8 @@ class SkeletonData {
 	/** All skins, including the default skin. */
 	public var skins:Array<Skin> = new Array<Skin>();
 	/** The skeleton's default skin. By default this skin contains all attachments that were not in a skin in Spine.
-	 * <p>
-	 * See {@link Skeleton#getAttachment(int, String)}. */
+	 *
+	 * See Skeleton#getAttachment(int, String). */
 	public var defaultSkin:Skin;
 	/** The skeleton's events. */
 	public var events:Array<EventData> = new Array<EventData>();

spine-haxe/spine-haxe/spine/SpacingMode.hx

@@ -30,8 +30,8 @@
 package spine;
 
 /** Controls how bones after the first bone are positioned along the path.
- * <p>
- * See <a href="https://esotericsoftware.com/spine-path-constraints#Spacing-mode">Spacing mode</a> in the Spine User Guide. */
+ *
+ * @see https://esotericsoftware.com/spine-path-constraints#Spacing-mode Spacing mode in the Spine User Guide */
 class SpacingMode {
 	public static var length(default, never):SpacingMode = new SpacingMode("length");
 	public static var fixed(default, never):SpacingMode = new SpacingMode("fixed");

spine-haxe/spine-haxe/spine/TransformConstraint.hx

@@ -31,8 +31,8 @@ package spine;
 
 /** Stores the current pose for a transform constraint. A transform constraint adjusts the world transform of the constrained
  * bones to match that of the target bone.
- * <p>
- * See <a href="https://esotericsoftware.com/spine-transform-constraints">Transform constraints</a> in the Spine User Guide. */
+ *
+ * @see https://esotericsoftware.com/spine-transform-constraints Transform constraints in the Spine User Guide */
 class TransformConstraint implements Updatable {
 	private var _data:TransformConstraintData;
 	private var _bones:Array<Bone>;

spine-haxe/spine-haxe/spine/TransformConstraintData.hx

@@ -32,7 +32,8 @@ package spine;
 /**
  * Stores the setup pose for a spine.TransformConstraint.
  * 
- * See <a href="https://esotericsoftware.com/spine-transform-constraints">Transform constraints</a> in the Spine User Guide.
+ * 
+ * @see https://esotericsoftware.com/spine-transform-constraints Transform constraints in the Spine User Guide
  */
 class TransformConstraintData extends ConstraintData {
 	private var _bones:Array<BoneData> = new Array<BoneData>();

spine-haxe/spine-haxe/spine/animation/AnimationState.hx

@@ -38,44 +38,44 @@ import spine.Skeleton;
 /**
  * Applies animations over time, queues animations for later playback, mixes (crossfading) between animations, and applies
  * multiple animations on top of each other (layering).
- * <p>
- * See <a href='https://esotericsoftware.com/spine-applying-animations/'>Applying Animations</a> in the Spine Runtimes Guide.
+ *
+ * @see https://esotericsoftware.com/spine-applying-animations/ Applying Animations in the Spine Runtimes Guide
  */
 class AnimationState {
 	/**
-	 * 1) A previously applied timeline has set this property.<br>
+	 * 1) A previously applied timeline has set this property.\n
 	 * Result: Mix from the current pose to the timeline pose.
 	 */
 	public static inline var SUBSEQUENT:Int = 0;
 	/**
-	 * 1) This is the first timeline to set this property.<br>
-	 * 2) The next track entry applied after this one does not have a timeline to set this property.<br>
+	 * 1) This is the first timeline to set this property.\n
+	 * 2) The next track entry applied after this one does not have a timeline to set this property.\n
 	 * Result: Mix from the setup pose to the timeline pose.
 	 */
 	public static inline var FIRST:Int = 1;
 	/**
-	 * 1) A previously applied timeline has set this property.<br>
-	 * 2) The next track entry to be applied does have a timeline to set this property.<br>
-	 * 3) The next track entry after that one does not have a timeline to set this property.<br>
+	 * 1) A previously applied timeline has set this property.\n
+	 * 2) The next track entry to be applied does have a timeline to set this property.\n
+	 * 3) The next track entry after that one does not have a timeline to set this property.\n
 	 * Result: Mix from the current pose to the timeline pose, but do not mix out. This avoids "dipping" when crossfading
 	 * animations that key the same property. A subsequent timeline will set this property using a mix.
 	 */
 	public static inline var HOLD_SUBSEQUENT:Int = 2;
 	/**
-	 * 1) This is the first timeline to set this property.<br>
-	 * 2) The next track entry to be applied does have a timeline to set this property.<br>
-	 * 3) The next track entry after that one does not have a timeline to set this property.<br>
+	 * 1) This is the first timeline to set this property.\n
+	 * 2) The next track entry to be applied does have a timeline to set this property.\n
+	 * 3) The next track entry after that one does not have a timeline to set this property.\n
 	 * Result: Mix from the setup pose to the timeline pose, but do not mix out. This avoids "dipping" when crossfading animations
 	 * that key the same property. A subsequent timeline will set this property using a mix.
 	 */
 	public static inline var HOLD_FIRST:Int = 3;
 	/**
-	 * 1) This is the first timeline to set this property.<br>
-	 * 2) The next track entry to be applied does have a timeline to set this property.<br>
-	 * 3) The next track entry after that one does have a timeline to set this property.<br>
-	 * 4) timelineHoldMix stores the first subsequent track entry that does not have a timeline to set this property.<br>
+	 * 1) This is the first timeline to set this property.\n
+	 * 2) The next track entry to be applied does have a timeline to set this property.\n
+	 * 3) The next track entry after that one does have a timeline to set this property.\n
+	 * 4) timelineHoldMix stores the first subsequent track entry that does not have a timeline to set this property.\n
 	 * Result: The same as HOLD except the mix percentage from the timelineHoldMix track entry is used. This handles when more than
-	 * 2 track entries in a row have a timeline that sets the same property.<br>
+	 * 2 track entries in a row have a timeline that sets the same property.\n
 	 * Eg, A -> B -> C -> D where A, B, and C have a timeline setting same property, but D does not. When A is applied, to avoid
 	 * "dipping" A is not mixed out, however D (the first entry that doesn't set the property) mixing in is used to mix out A
 	 * (which affects B and C). Without using D to mix out, A would be applied fully until mixing completes, then snap to the mixed
@@ -548,7 +548,7 @@ class AnimationState {
 
 	/**
 	 * Removes all animations from all tracks, leaving skeletons in their current pose.
-	 * <p>
+	 *
 	 * It may be desired to use spine.animation.AnimationState.setEmptyAnimations() to mix the skeletons back to the setup pose,
 	 * rather than leaving them in their current pose.
 	 */
@@ -565,7 +565,7 @@ class AnimationState {
 
 	/**
 	 * Removes all animations from the track, leaving skeletons in their current pose.
-	 * <p>
+	 *
 	 * It may be desired to use spine.animation.AnimationState.setEmptyAnimation() to mix the skeletons back to the setup pose,
 	 * rather than leaving them in their current pose.
 	 */
@@ -619,7 +619,7 @@ class AnimationState {
 
 	/**
 	 * Sets an animation by name.
-	 * <p>
+	 *
 	 * See spine.animation.AnimationState.setAnimation().
 	 */
 	public function setAnimationByName(trackIndex:Int, animationName:String, loop:Bool):TrackEntry {
@@ -663,7 +663,7 @@ class AnimationState {
 
 	/**
 	 * Queues an animation by name.
-	 * <p>
+	 *
 	 * See spine.animation.AnimationState.addAnimation().
 	 */
 	public function addAnimationByName(trackIndex:Int, animationName:String, loop:Bool, delay:Float):TrackEntry {
@@ -713,13 +713,13 @@ class AnimationState {
 	/**
 	 * Sets an empty animation for a track, discarding any queued animations, and sets the track entry's
 	 * spine.animation.TrackEntry.getMixDuration(). An empty animation has no timelines and serves as a placeholder for mixing in or out.
-	 * <p>
+	 *
 	 * Mixing out is done by setting an empty animation with a mix duration using either spine.animation.AnimationState.setEmptyAnimation(),
 	 * spine.animation.AnimationState.setEmptyAnimations(), or spine.animation.AnimationState.addEmptyAnimation(). Mixing to an empty animation causes
 	 * the previous animation to be applied less and less over the mix duration. Properties keyed in the previous animation
 	 * transition to the value from lower tracks or to the setup pose value if no lower tracks key the property. A mix duration of
 	 * 0 still mixes out over one frame.
-	 * <p>
+	 *
 	 * Mixing in is done by first setting an empty animation, then adding an animation using
 	 * spine.animation.AnimationState.addAnimation() with the desired delay (an empty animation has a duration of 0) and on
 	 * the returned track entry, set the spine.animation.TrackEntry.setMixDuration(). Mixing from an empty animation causes the new
@@ -738,7 +738,7 @@ class AnimationState {
 	 * Adds an empty animation to be played after the current or last queued animation for a track, and sets the track entry's
 	 * spine.animation.TrackEntry.getMixDuration(). If the track is empty, it is equivalent to calling
 	 * spine.animation.AnimationState.setEmptyAnimation().
-	 * <p>
+	 *
 	 * See spine.animation.AnimationState.setEmptyAnimation().
 	 * @param delay If > 0, sets spine.animation.TrackEntry.getDelay(). If <= 0, the delay set is the duration of the previous track entry
 	 *           minus any mix duration plus the specified delay (ie the mix ends at (delay = 0) or

spine-haxe/spine-haxe/spine/animation/AttachmentTimeline.hx

@@ -56,7 +56,7 @@ class AttachmentTimeline extends Timeline implements SlotTimeline {
 	}
 
 	/** Sets the time and attachment name for the specified frame.
-	 * @param frame Between 0 and <code>frameCount</code>, inclusive.
+	 * @param frame Between 0 and frameCount, inclusive.
 	 * @param time The frame time in seconds. */
 	public function setFrame(frame:Int, time:Float, attachmentName:String):Void {
 		frames[frame] = time;

spine-haxe/spine-haxe/spine/animation/CurveTimeline.hx

@@ -48,18 +48,18 @@ class CurveTimeline extends Timeline {
 	}
 
 	/** Sets the specified frame to linear interpolation.
-	 * @param frame Between 0 and <code>frameCount - 1</code>, inclusive. */
+	 * @param frame Between 0 and frameCount - 1, inclusive. */
 	public function setLinear(frame:Int):Void {
 		curves[frame] = LINEAR;
 	}
 
 	/** Sets the specified frame to stepped interpolation.
-	 * @param frame Between 0 and <code>frameCount - 1</code>, inclusive. */
+	 * @param frame Between 0 and frameCount - 1, inclusive. */
 	public function setStepped(frame:Int):Void {
 		curves[frame] = STEPPED;
 	}
 
-	/** Shrinks the storage for Bezier curves, for use when <code>bezierCount</code> (specified in the constructor) was larger
+	/** Shrinks the storage for Bezier curves, for use when bezierCount (specified in the constructor) was larger
 	 * than the actual number of Bezier curves. */
 	public function shrink(bezierCount:Int):Void {
 		var size:Int = getFrameCount() + bezierCount * BEZIER_SIZE;
@@ -68,9 +68,9 @@ class CurveTimeline extends Timeline {
 
 	/** Stores the segments for the specified Bezier curve. For timelines that modify multiple values, there may be more than
 	 * one curve per frame.
-	 * @param bezier The ordinal of this Bezier curve for this timeline, between 0 and <code>bezierCount - 1</code> (specified
+	 * @param bezier The ordinal of this Bezier curve for this timeline, between 0 and bezierCount - 1 (specified
 	 *           in the constructor), inclusive.
-	 * @param frame Between 0 and <code>frameCount - 1</code>, inclusive.
+	 * @param frame Between 0 and frameCount - 1, inclusive.
 	 * @param value The index of the value for the frame this curve is used for.
 	 * @param time1 The time for the first key.
 	 * @param value1 The value for the first key.
@@ -109,8 +109,8 @@ class CurveTimeline extends Timeline {
 	}
 
 	/** Returns the Bezier interpolated value for the specified time.
-	 * @param frameIndex The index into Timeline.getFrames() for the values of the frame before <code>time</code>.
-	 * @param valueOffset The offset from <code>frameIndex</code> to the value this curve is used for.
+	 * @param frameIndex The index into Timeline.getFrames() for the values of the frame before time.
+	 * @param valueOffset The offset from frameIndex to the value this curve is used for.
 	 * @param i The index of the Bezier segments. See CurveTimeline.getCurveType(). */
 	public function getBezierValue(time:Float, frameIndex:Int, valueOffset:Int, i:Int):Float {
 		var x:Float, y:Float;

spine-haxe/spine-haxe/spine/animation/CurveTimeline1.hx

@@ -46,7 +46,7 @@ class CurveTimeline1 extends CurveTimeline {
 	}
 
 	/** Sets the time and value for the specified frame.
-	 * @param frame Between 0 and <code>frameCount</code>, inclusive.
+	 * @param frame Between 0 and frameCount, inclusive.
 	 * @param time The frame time in seconds. */
 	public function setFrame(frame:Int, time:Float, value1:Float):Void {
 		frame <<= 1;

spine-haxe/spine-haxe/spine/animation/CurveTimeline2.hx

@@ -47,7 +47,7 @@ class CurveTimeline2 extends CurveTimeline {
 	}
 
 	/** Sets the time and values for the specified frame.
-	 * @param frame Between 0 and <code>frameCount</code>, inclusive.
+	 * @param frame Between 0 and frameCount, inclusive.
 	 * @param time The frame time in seconds. */
 	public function setFrame(frame:Int, time:Float, value1:Float, value2:Float):Void {
 		frame *= ENTRIES;

spine-haxe/spine-haxe/spine/animation/DeformTimeline.hx

@@ -65,7 +65,7 @@ class DeformTimeline extends CurveTimeline implements SlotTimeline {
 	}
 
 	/** Sets the time and vertices for the specified frame.
-	 * @param frame Between 0 and <code>frameCount</code>, inclusive.
+	 * @param frame Between 0 and frameCount, inclusive.
 	 * @param time The frame time in seconds.
 	 * @param verticesOrDeform Vertex positions for an unweighted VertexAttachment, or deform offsets if it has weights. */
 	public function setFrame(frame:Int, time:Float, verticesOrDeform:Array<Float>):Void {
@@ -113,7 +113,7 @@ class DeformTimeline extends CurveTimeline implements SlotTimeline {
 	}
 
 	/** Returns the interpolated percentage for the specified time.
-	 * @param frame The frame before <code>time</code>. */
+	 * @param frame The frame before time. */
 	private function getCurvePercent(time:Float, frame:Int):Float {
 		var i:Int = Std.int(curves[frame]);
 		var x:Float;

spine-haxe/spine-haxe/spine/animation/DrawOrderTimeline.hx

@@ -33,7 +33,7 @@ import spine.Event;
 import spine.Skeleton;
 import spine.Slot;
 
-/** Changes a skeleton's {@link Skeleton#drawOrder}. */
+/** Changes a skeleton's Skeleton#drawOrder. */
 class DrawOrderTimeline extends Timeline {
 	/** The draw order for each frame. See setFrame(). */
 	public var drawOrders:Array<Array<Int>>;
@@ -51,7 +51,7 @@ class DrawOrderTimeline extends Timeline {
 	}
 
 	/** Sets the time and draw order for the specified frame.
-	 * @param frame Between 0 and <code>frameCount</code>, inclusive.
+	 * @param frame Between 0 and frameCount, inclusive.
 	 * @param time The frame time in seconds.
 	 * @param drawOrder For each slot in spine.Skeleton.slots, the index of the slot in the new draw order. May be null to use setup pose draw order. */
 	public function setFrame(frame:Int, time:Float, drawOrder:Array<Int>):Void {

spine-haxe/spine-haxe/spine/animation/EventTimeline.hx

@@ -49,13 +49,13 @@ class EventTimeline extends Timeline {
 	}
 
 	/** Sets the time and event for the specified frame.
-	 * @param frame Between 0 and <code>frameCount</code>, inclusive. */
+	 * @param frame Between 0 and frameCount, inclusive. */
 	public function setFrame(frame:Int, event:Event):Void {
 		frames[frame] = event.time;
 		events[frame] = event;
 	}
 
-	/** Fires events for frames > <code>lastTime</code> and <= <code>time</code>. */
+	/** Fires events for frames > lastTime and <= time. */
 	public override function apply(skeleton:Skeleton, lastTime:Float, time:Float, events:Array<Event>, alpha:Float, blend:MixBlend,
 			direction:MixDirection):Void {
 		if (events == null)

spine-haxe/spine-haxe/spine/animation/IkConstraintTimeline.hx

@@ -57,7 +57,7 @@ class IkConstraintTimeline extends CurveTimeline {
 	}
 
 	/** Sets the time, mix, softness, bend direction, compress, and stretch for the specified frame.
-	 * @param frame Between 0 and <code>frameCount</code>, inclusive.
+	 * @param frame Between 0 and frameCount, inclusive.
 	 * @param time The frame time in seconds.
 	 * @param bendDirection 1 or -1. */
 	public function setFrame(frame:Int, time:Float, mix:Float, softness:Float, bendDirection:Int, compress:Bool, stretch:Bool):Void {

spine-haxe/spine-haxe/spine/animation/InheritTimeline.hx

@@ -54,7 +54,7 @@ class InheritTimeline extends Timeline implements BoneTimeline {
 	}
 
 	/** Sets the transform mode for the specified frame.
-	 * @param frame Between 0 and <code>frameCount</code>, inclusive.
+	 * @param frame Between 0 and frameCount, inclusive.
 	 * @param time The frame time in seconds. */
 	public function setFrame(frame:Int, time:Float, inherit: Inherit):Void {
 		frame *= ENTRIES;

spine-haxe/spine-haxe/spine/animation/Listeners.hx

@@ -88,7 +88,7 @@ class EventListeners {
 
 	/** Invoked when this entry's animation triggers an event. This may occur during mixing (after
 	 * interrupt(TrackEntry)), see spine.animation.TrackEntry.eventThreshold.
-	 * <p>
+	 *
 	 * Because this event is triggered at the end of spine.animation.AnimationState.apply(Skeleton), any animations set in response to
 	 * the event won't be applied until the next time the AnimationState is applied. */
 	public function invoke(entry:TrackEntry, event:Event) {

spine-haxe/spine-haxe/spine/animation/MixBlend.hx

@@ -30,7 +30,7 @@
 package spine.animation;
 
 /** Controls how timeline values are mixed with setup pose values or current pose values when a timeline is applied with
- * <code>alpha</code> < 1.
+ * alpha < 1.
  * 
  * @see spine.animation.Timeline.apply() */
 class MixBlend {
@@ -47,17 +47,17 @@ class MixBlend {
 	 * the setup value. Timelines which perform instant transitions, such as spine.animation.DrawOrderTimeline or
 	 * spine.animation.AttachmentTimeline, use the setup value before the first frame.
 	 * 
-	 * <code>first</code> is intended for the first animations applied, not for animations layered on top of those. */
+	 * first is intended for the first animations applied, not for animations layered on top of those. */
 	public static var first(default, never):MixBlend = new MixBlend(1);
 	/** Transitions from the current value to the timeline value. No change is made before the first frame (the current value is
 	 * kept until the first frame).
 	 * 
-	 * <code>replace</code> is intended for animations layered on top of others, not for the first animations applied. */
+	 * replace is intended for animations layered on top of others, not for the first animations applied. */
 	public static var replace(default, never):MixBlend = new MixBlend(2);
 	/** Transitions from the current value to the current value plus the timeline value. No change is made before the first
 	 * frame (the current value is kept until the first frame).
 	 * 
-	 * <code>add</code> is intended for animations layered on top of others, not for the first animations applied. Properties
+	 * add is intended for animations layered on top of others, not for the first animations applied. Properties
 	 * set by additive animations must be set manually or by another animation before applying the additive animations, else the
 	 * property values will increase each time the additive animations are applied. */
 	public static var add(default, never):MixBlend = new MixBlend(3);

spine-haxe/spine-haxe/spine/animation/PathConstraintMixTimeline.hx

@@ -55,7 +55,7 @@ class PathConstraintMixTimeline extends CurveTimeline {
 	}
 
 	/** Sets the time and color for the specified frame.
-	 * @param frame Between 0 and <code>frameCount</code>, inclusive.
+	 * @param frame Between 0 and frameCount, inclusive.
 	 * @param time The frame time in seconds. */
 	public function setFrame(frame:Int, time:Float, mixRotate:Float, mixX:Float, mixY:Float):Void {
 		frame <<= 2;

spine-haxe/spine-haxe/spine/animation/PathConstraintSpacingTimeline.hx

@@ -33,9 +33,9 @@ import spine.Event;
 import spine.PathConstraint;
 import spine.Skeleton;
 
-/** Changes a path constraint's {@link PathConstraint#spacing}. */
+/** Changes a path constraint's PathConstraint#spacing. */
 class PathConstraintSpacingTimeline extends CurveTimeline1 {
-	/** The index of the path constraint in {@link Skeleton#pathConstraints} that will be changed when this timeline is
+	/** The index of the path constraint in Skeleton#pathConstraints that will be changed when this timeline is
 	 * applied. */
 	public var constraintIndex:Int = 0;
 

spine-haxe/spine-haxe/spine/animation/PhysicsConstraintResetTimeline.hx

@@ -35,7 +35,7 @@ import spine.Skeleton;
 
 /** Resets a physics constraint when specific animation times are reached. */
 class PhysicsConstraintResetTimeline extends Timeline {
-	/** The index of the physics constraint in {@link Skeleton#physicsConstraints} that will be reset when this timeline is
+	/** The index of the physics constraint in Skeleton#physicsConstraints that will be reset when this timeline is
 	 * applied, or -1 if all physics constraints in the skeleton will be reset. */
 	public var constraintIndex:Int = 0;
 
@@ -51,12 +51,12 @@ class PhysicsConstraintResetTimeline extends Timeline {
 	}
 
 	/** Sets the time for the specified frame.
-	 * @param frame Between 0 and <code>frameCount</code>, inclusive. */
+	 * @param frame Between 0 and frameCount, inclusive. */
 	public function setFrame(frame:Int, time:Float):Void {
 		frames[frame] = time;
 	}
 
-	/** Resets the physics constraint when frames > <code>lastTime</code> and <= <code>time</code>. */
+	/** Resets the physics constraint when frames > lastTime and <= time. */
 	public override function apply(skeleton:Skeleton, lastTime:Float, time:Float, firedEvents:Array<Event>, alpha:Float, blend:MixBlend,
 			direction:MixDirection):Void {
 		var constraint:PhysicsConstraint = null;

spine-haxe/spine-haxe/spine/animation/RGB2Timeline.hx

@@ -57,7 +57,7 @@ class RGB2Timeline extends CurveTimeline implements SlotTimeline {
 	}
 
 	/** Sets the time, light color, and dark color for the specified frame.
-	 * @param frame Between 0 and <code>frameCount</code>, inclusive.
+	 * @param frame Between 0 and frameCount, inclusive.
 	 * @param time The frame time in seconds. */
 	public function setFrame(frame:Int, time:Float, r:Float, g:Float, b:Float, r2:Float, g2:Float, b2:Float):Void {
 		frame *= ENTRIES;

spine-haxe/spine-haxe/spine/animation/RGBA2Timeline.hx

@@ -62,7 +62,7 @@ class RGBA2Timeline extends CurveTimeline implements SlotTimeline {
 	}
 
 	/** Sets the time, light color, and dark color for the specified frame.
-	 * @param frame Between 0 and <code>frameCount</code>, inclusive.
+	 * @param frame Between 0 and frameCount, inclusive.
 	 * @param time The frame time in seconds. */
 	public function setFrame(frame:Int, time:Float, r:Float, g:Float, b:Float, a:Float, r2:Float, g2:Float, b2:Float):Void {
 		frame <<= 3;

spine-haxe/spine-haxe/spine/animation/RGBTimeline.hx

@@ -52,7 +52,7 @@ class RGBTimeline extends CurveTimeline implements SlotTimeline {
 	}
 
 	/** Sets the time and color for the specified frame.
-	 * @param frame Between 0 and <code>frameCount</code>, inclusive.
+	 * @param frame Between 0 and frameCount, inclusive.
 	 * @param time The frame time in seconds. */
 	public function setFrame(frame:Int, time:Float, r:Float, g:Float, b:Float):Void {
 		frame <<= 2;

spine-haxe/spine-haxe/spine/animation/SequenceTimeline.hx

@@ -32,7 +32,7 @@ package spine.animation;
 import spine.attachments.VertexAttachment;
 import spine.attachments.Attachment;
 
-/** Changes a slot's {@link Slot#getSequenceIndex()} for an attachment's {@link Sequence}. */
+/** Changes a slot's Slot#getSequenceIndex() for an attachment's Sequence. */
 class SequenceTimeline extends Timeline implements SlotTimeline {
 	static var ENTRIES = 3;
 	static var MODE = 1;
@@ -62,7 +62,7 @@ class SequenceTimeline extends Timeline implements SlotTimeline {
 	}
 
 	/** Sets the time, mode, index, and frame time for the specified frame.
-	 * @param frame Between 0 and <code>frameCount</code>, inclusive.
+	 * @param frame Between 0 and frameCount, inclusive.
 	 * @param time Seconds between frames. */
 	public function setFrame(frame:Int, time:Float, mode:SequenceMode, index:Int, delay:Float) {
 		frame *= SequenceTimeline.ENTRIES;

spine-haxe/spine-haxe/spine/animation/Timeline.hx

@@ -68,18 +68,18 @@ class Timeline {
 	 *           skeleton components that the timeline may change.
 	 * @param lastTime The last time in seconds this timeline was applied. Timelines such as spine.animation.EventTimeline trigger only
 	 *           at specific times rather than every frame. In that case, the timeline triggers everything between
-	 *           <code>lastTime</code> (exclusive) and <code>time</code> (inclusive). Pass -1 the first time an animation is
+	 *           lastTime (exclusive) and time (inclusive). Pass -1 the first time an animation is
 	 *           applied to ensure frame 0 is triggered.
 	 * @param time The time in seconds that the skeleton is being posed for. Most timelines find the frame before and the frame
 	 *           after this time and interpolate between the frame values. If beyond the last frame, the last frame will be
 	 *           applied.
 	 * @param events If any events are fired, they are added to this list. Can be null to ignore fired events or if the timeline
 	 *           does not fire events.
-	 * @param alpha 0 applies the current or setup value (depending on <code>blend</code>). 1 applies the timeline value.
+	 * @param alpha 0 applies the current or setup value (depending on blend). 1 applies the timeline value.
 	 *           Between 0 and 1 applies a value between the current or setup value and the timeline value. By adjusting
-	 *           <code>alpha</code> over time, an animation can be mixed in or out. <code>alpha</code> can also be useful to
+	 *           alpha over time, an animation can be mixed in or out. alpha can also be useful to
 	 *           apply animations on top of each other (layering).
-	 * @param blend Controls how mixing is applied when <code>alpha</code> < 1.
+	 * @param blend Controls how mixing is applied when alpha < 1.
 	 * @param direction Indicates whether the timeline is mixing in or out. Used by timelines which perform instant transitions,
 	 *           such as spine.animation.DrawOrderTimeline or spine.animation.AttachmentTimeline, and others such as spine.animation.ScaleTimeline.
 	 */
@@ -88,8 +88,8 @@ class Timeline {
 	}
 
 	/** Linear search using a stride of 1.
-	 * @param time Must be >= the first value in <code>frames</code>.
-	 * @return The index of the first value <= <code>time</code>.
+	 * @param time Must be >= the first value in frames.
+	 * @return The index of the first value <= time.
 	 */
 	public static function search1(frames:Array<Float>, time:Float):Int {
 		var n:Int = frames.length;
@@ -101,8 +101,8 @@ class Timeline {
 	}
 
 	/** Linear search using the specified stride.
-	 * @param time Must be >= the first value in <code>frames</code>.
-	 * @return The index of the first value <= <code>time</code>.
+	 * @param time Must be >= the first value in frames.
+	 * @return The index of the first value <= time.
 	 */
 	public static function search(values:Array<Float>, time:Float, step:Int):Int {
 		var n:Int = values.length;

spine-haxe/spine-haxe/spine/animation/TrackEntry.hx

@@ -33,14 +33,14 @@ import spine.animation.Listeners.EventListeners;
 import spine.Poolable;
 
 /** Stores settings and other state for the playback of an animation on an spine.animation.AnimationState track.
- * <p>
+ *
  * References to a track entry must not be kept after the AnimationStateListener.dispose(TrackEntry) event occurs. */
 class TrackEntry implements Poolable {
 	/** The animation to apply for this track entry. */
 	public var animation:Animation;
 	/** The animation queued to start after this animation, or null if there is none. next makes up a doubly linked
 	 * list.
-	 * <p>
+	 *
 	 * See spine.animation.AnimationState.clearNext(TrackEntry) to truncate the list. */
 	public var next:TrackEntry;
 	/** The animation queued to play before this animation, or null. previous makes up a doubly linked list. */
@@ -58,7 +58,7 @@ class TrackEntry implements Poolable {
 	public var onComplete:Listeners = new Listeners();
 	public var onEvent:EventListeners = new EventListeners();
 	/** The index of the track where this track entry is either current or queued.
-	 * <p>
+	 *
 	 * See spine.animation.AnimationState.getCurrent(int). */
 	public var trackIndex:Int = 0;
 	/** If true, the animation will repeat. If false it will not, instead its last frame is applied if played beyond its
@@ -68,13 +68,13 @@ class TrackEntry implements Poolable {
 	public var reverse:Bool = false;
 	/** If true, when mixing from the previous animation to this animation, the previous animation is applied as normal instead
 	 * of being mixed out.
-	 * <p>
+	 *
 	 * When mixing between animations that key the same property, if a lower track also keys that property then the value will
 	 * briefly dip toward the lower track value during the mix. This happens because the first animation mixes from 100% to 0%
 	 * while the second animation mixes from 0% to 100%. Setting holdPrevious to true applies the first animation
 	 * at 100% during the mix so the lower track value is overwritten. Such dipping does not occur on the lowest track which
 	 * keys the property, only when a higher track also keys the property.
-	 * <p>
+	 *
 	 * Snapping will occur if holdPrevious is true and this animation does not key all the same properties as the
 	 * previous animation. */
 	public var holdPrevious:Bool = false;
@@ -94,7 +94,7 @@ class TrackEntry implements Poolable {
 	 * 0, so draw order timelines are not applied while this animation is being mixed out. */
 	public var mixDrawOrderThreshold:Float = 0;
 	/** Seconds when this animation starts, both initially and after looping. Defaults to 0.
-	 * <p>
+	 *
 	 * When changing the animationStart time, it often makes sense to set TrackEntry.getAnimationLast() to the same
 	 * value to prevent timeline keys before the start time from triggering. */
 	public var animationStart:Float = 0;
@@ -113,9 +113,9 @@ class TrackEntry implements Poolable {
 	* delay is the time from the start of the previous animation to when this track entry will become the current
 	* track entry (ie when the previous track entry TrackEntry.getTrackTime() >= this track entry's
 	* delay).
-	* <p>
+	*
 	* TrackEntry.getTimeScale() affects the delay.
-	* <p>
+	*
 	* When passing delay <= 0 to spine.animation.AnimationState.addAnimation(int, Animation, boolean, float) this
 	* delay is set using a mix duration from spine.animation.AnimationStateData. To change the TrackEntry.getMixDuration()
 	* afterward, use TrackEntry.setMixDuration(float, float) so this delay is adjusted. */
@@ -131,27 +131,27 @@ class TrackEntry implements Poolable {
 	 * value, meaning the animation will be applied until a new animation is set or the track is cleared. If the track end time
 	 * is reached, no other animations are queued for playback, and mixing from any previous animations is complete, then the
 	 * properties keyed by the animation are set to the setup pose and the track is cleared.
-	 * <p>
+	 *
 	 * It may be desired to use spine.animation.AnimationState.addEmptyAnimation(int, float, float) rather than have the animation
 	 * abruptly cease being applied. */
 	public var trackEnd:Float = 0;
 	/** Multiplier for the delta time when this track entry is updated, causing time for this animation to pass slower or
 	 * faster. Defaults to 1.
-	 * <p>
+	 *
 	 * Values < 0 are not supported. To play an animation in reverse, use TrackEntry.getReverse().
-	 * <p>
+	 *
 	 * TrackEntry.getMixTime() is not affected by track entry time scale, so TrackEntry.getMixDuration() may need to be adjusted to
 	 * match the animation speed.
-	 * <p>
+	 *
 	 * When using spine.animation.AnimationState.addAnimation(int, Animation, boolean, float) with a delay <= 0, the
 	 * TrackEntry.getDelay() is set using the mix duration from the spine.animation.AnimationStateData, assuming time scale to be 1. If
 	 * the time scale is not 1, the delay may need to be adjusted.
-	 * <p>
+	 *
 	 * See AnimationState spine.animation.AnimationState.getTimeScale() for affecting all animations. */
 	public var timeScale:Float = 0;
 	/** Values < 1 mix this animation with the skeleton's current pose (usually the pose resulting from lower tracks). Defaults
 	 * to 1, which overwrites the skeleton's current pose with this animation.
-	 * <p>
+	 *
 	 * Typically track 0 is used to completely pose the skeleton, then alpha is used on higher tracks. It doesn't make sense to
 	 * use alpha on track 0 if the skeleton pose is from the last frame render. */
 	public var alpha:Float = 0;
@@ -160,28 +160,28 @@ class TrackEntry implements Poolable {
 	public var mixTime:Float = 0;
 	/** Seconds for mixing from the previous animation to this animation. Defaults to the value provided by AnimationStateData
 	 * spine.animation.AnimationStateData.getMix(Animation, Animation) based on the animation before this animation (if any).
-	 * <p>
+	 *
 	 * A mix duration of 0 still mixes out over one frame to provide the track entry being mixed out a chance to revert the
 	 * properties it was animating. A mix duration of 0 can be set at any time to end the mix on the next
 	 * spine.animation.AnimationState.update(float) update.
-	 * <p>
+	 *
 	 * The mixDuration can be set manually rather than use the value from
 	 * spine.animation.AnimationStateData.getMix(Animation, Animation). In that case, the mixDuration can be set for a new
 	 * track entry only before spine.animation.AnimationState.update(float) is first called.
-	 * <p>
+	 *
 	 * When using spine.animation.AnimationState.addAnimation(int, Animation, boolean, float) with a delay <= 0, the
 	 * TrackEntry.getDelay() is set using the mix duration from the spine.animation.AnimationStateData. If mixDuration is set
-	 * afterward, the delay may need to be adjusted. For example:<br>
-	 * entry.delay = entry.previous.getTrackComplete() - entry.mixDuration;<br>
-	 * Alternatively, TrackEntry.setMixDuration(float, float) can be used to recompute the delay:<br>
+	 * afterward, the delay may need to be adjusted. For example:\n
+	 * entry.delay = entry.previous.getTrackComplete() - entry.mixDuration;\n
+	 * Alternatively, TrackEntry.setMixDuration(float, float) can be used to recompute the delay:\n
 	 * entry.setMixDuration(0.25f, 0); */
 	public var mixDuration:Float = 0;
 	public var interruptAlpha:Float = 0;
 	public var totalAlpha:Float = 0;
 	/** Controls how properties keyed in the animation are mixed with lower tracks. Defaults to spine.animation.MixBlend.replace.
-	 * <p>
+	 *
 	 * Track entries on track 0 ignore this setting and always use spine.animation.MixBlend.first.
-	 * <p>
+	 *
 	 * The mixBlend can be set for a new track entry only before spine.animation.AnimationState.apply(Skeleton) is first
 	 * called. */
 	public var mixBlend:MixBlend = MixBlend.replace;
@@ -190,7 +190,7 @@ class TrackEntry implements Poolable {
 	public var timelinesRotation:Array<Float> = new Array<Float>();
 	/** If true, mixing rotation between tracks always uses the shortest rotation direction. If the rotation is animated, the
 	 * shortest rotation direction may change during the mix.
-	 * <p>
+	 *
 	 * If false, the shortest rotation direction is remembered when the mix starts and the same direction is used for the rest
 	 * of the mix. Defaults to false. */
 	public var shortestRotation = false;
@@ -204,7 +204,7 @@ class TrackEntry implements Poolable {
 
 	/** Uses TrackEntry.getTrackTime() to compute the animationTime. When the trackTime is 0, the
 	 * animationTime is equal to the animationStart time.
-	 * <p>
+	 *
 	 * The animationTime is between TrackEntry.getAnimationStart() and TrackEntry.getAnimationEnd(), except if this
 	 * track entry is non-looping and TrackEntry.getAnimationEnd() is >= to the animation spine.animation.Animation.duration, then
 	 * animationTime continues to increase past TrackEntry.getAnimationEnd(). */
@@ -233,7 +233,7 @@ class TrackEntry implements Poolable {
 	}
 
 	/** Returns true if this track entry has been applied at least once.
-	 * <p>
+	 *
 	 * See spine.animation.AnimationState.apply(Skeleton). */
 	public function wasApplied() {
 		return nextTrackLast != -1;
@@ -264,7 +264,7 @@ class TrackEntry implements Poolable {
 
 	/** Resets the rotation directions for mixing this entry's rotate timelines. This can be useful to avoid bones rotating the
 	 * long way around when using TrackEntry.getAlpha() and starting animations on other tracks.
-	 * <p>
+	 *
 	 * Mixing with spine.animation.MixBlend.replace involves finding a rotation between two others, which has two possible solutions:
 	 * the short way or the long way around. The two rotations likely change over time, so which direction is the short or long
 	 * way also changes. If the short way was always chosen, bones would flip to the other side when that direction became the

spine-haxe/spine-haxe/spine/animation/TransformConstraintTimeline.hx

@@ -60,7 +60,7 @@ class TransformConstraintTimeline extends CurveTimeline {
 	}
 
 	/** Sets the time, rotate mix, translate mix, scale mix, and shear mix for the specified frame.
-	 * @param frame Between 0 and <code>frameCount</code>, inclusive.
+	 * @param frame Between 0 and frameCount, inclusive.
 	 * @param time The frame time in seconds. */
 	public function setFrame(frame:Int, time:Float, mixRotate:Float, mixX:Float, mixY:Float, mixScaleX:Float, mixScaleY:Float, mixShearY:Float):Void {
 		frame *= ENTRIES;

spine-haxe/spine-haxe/spine/attachments/AtlasAttachmentLoader.hx

@@ -34,9 +34,8 @@ import spine.Skin;
 
 /**
  * The interface which can be implemented to customize creating and populating attachments.
- * <p>
- * See <a href='https://esotericsoftware.com/spine-loading-skeleton-data#AttachmentLoader'>Loading skeleton data</a> in the Spine
- * Runtimes Guide.
+ *
+ * @see https://esotericsoftware.com/spine-loading-skeleton-data#AttachmentLoader Loading skeleton data in the Spine Runtimes Guide
  */
 class AtlasAttachmentLoader implements AttachmentLoader {
 	private var atlas:TextureAtlas;

spine-haxe/spine-haxe/spine/attachments/AttachmentLoader.hx

@@ -32,9 +32,9 @@ package spine.attachments;
 import spine.Skin;
 
 /** The interface which can be implemented to customize creating and populating attachments.
- * <p>
- * See <a href='https://esotericsoftware.com/spine-loading-skeleton-data#AttachmentLoader'>Loading skeleton data</a> in the Spine
- * Runtimes Guide. */
+ *
+ * @see https://esotericsoftware.com/spine-loading-skeleton-data#AttachmentLoader Loading skeleton data in the Spine Runtimes Guide
+ */
 interface AttachmentLoader {
 	/** @return May be null to not load the attachment. */
 	function newRegionAttachment(skin:Skin, name:String, path:String, sequence:Sequence):RegionAttachment;

spine-haxe/spine-haxe/spine/attachments/BoundingBoxAttachment.hx

@@ -33,9 +33,10 @@ import spine.Color;
 
 /** An attachment with vertices that make up a polygon. Can be used for hit detection, creating physics bodies, spawning particle
  * effects, and more.
- * <p>
- * See {@link SkeletonBounds} and <a href="https://esotericsoftware.com/spine-bounding-boxes">Bounding Boxes</a> in the Spine User
- * Guide. */
+ *
+ * @see SkeletonBounds
+ * @see https://esotericsoftware.com/spine-bounding-boxes Bounding Boxes in the Spine User Guide
+ */
 class BoundingBoxAttachment extends VertexAttachment {
 	/** The color of the bounding box as it was in Spine, or a default color if nonessential data was not exported. Bounding boxes
 	 * are not usually rendered at runtime. */

spine-haxe/spine-haxe/spine/attachments/MeshAttachment.hx

@@ -35,15 +35,15 @@ import spine.atlas.TextureAtlasPage;
 
 /** An attachment that displays a textured mesh. A mesh has hull vertices and internal vertices within the hull. Holes are not
  * supported. Each vertex has UVs (texture coordinates) and triangles are used to map an image on to the mesh.
- * <p>
- * See <a href="https://esotericsoftware.com/spine-meshes">Mesh attachments</a> in the Spine User Guide. */
+ *
+ * @see https://esotericsoftware.com/spine-meshes Mesh attachments in the Spine User Guide */
 class MeshAttachment extends VertexAttachment implements HasTextureRegion {
 	public var region:TextureRegion;
 	public var path:String;
 	/** The UV pair for each vertex, normalized within the texture region. */
 	public var regionUVs = new Array<Float>();
 	/** The UV pair for each vertex, normalized within the entire texture.
-	 * See {@link #updateRegion()}. */
+	 * See #updateRegion(). */
 	public var uvs = new Array<Float>();
 	/** Triplets of vertex indices which describe the mesh's triangulation. */
 	public var triangles = new Array<Int>();
@@ -52,7 +52,7 @@ class MeshAttachment extends VertexAttachment implements HasTextureRegion {
 	public var width:Float = 0;
 	/** The height of the mesh's image, or zero if nonessential data was not exported. */
 	public var height:Float = 0;
-	/** The number of entries at the beginning of {@link #vertices} that make up the mesh hull. */
+	/** The number of entries at the beginning of #vertices that make up the mesh hull. */
 	public var hullLength:Int = 0;
 	/** Vertex index pairs describing edges for controlling triangulation, or null if nonessential data was not exported. Mesh
 	 * triangles will never cross edges. Triangulation is not performed at runtime. */
@@ -60,9 +60,9 @@ class MeshAttachment extends VertexAttachment implements HasTextureRegion {
 	public var rendererObject:Dynamic;
 	public var sequence:Sequence;
 
-	/** The parent mesh if this is a linked mesh, else null. A linked mesh shares the {@link #bones}, {@link #vertices},
-	 * {@link #regionUVs}, {@link #triangles}, {@link #hullLength}, {@link #edges}, {@link #width}, and {@link #height} with the
-	 * parent mesh, but may have a different {@link #name} or {@link #path} (and therefore a different texture). */
+	/** The parent mesh if this is a linked mesh, else null. A linked mesh shares the #bones, #vertices,
+	 * #regionUVs, #triangles, #hullLength, #edges, #width, and #height with the
+	 * parent mesh, but may have a different #name or #path (and therefore a different texture). */
 	private var _parentMesh:MeshAttachment;
 
 	/** Copy constructor. Use newLinkedMesh() if the other mesh is a linked mesh. */

spine-haxe/spine-haxe/spine/attachments/PathAttachment.hx

@@ -32,8 +32,10 @@ package spine.attachments;
 import spine.Color;
 
 /** An attachment whose vertices make up a composite Bezier curve.
- * <p>
- * See {@link PathConstraint} and <a href="https://esotericsoftware.com/spine-paths">Paths</a> in the Spine User Guide. */
+ *
+ * @see PathConstraint
+ * @see https://esotericsoftware.com/spine-paths Paths in the Spine User Guide
+ */
 class PathAttachment extends VertexAttachment {
 	/** The lengths along the path in the setup pose from the start of the path to the end of each Bezier curve. */
 	public var lengths:Array<Float>;

spine-haxe/spine-haxe/spine/attachments/PointAttachment.hx

@@ -36,8 +36,8 @@ import spine.MathUtils;
 /** An attachment which is a single point and a rotation. This can be used to spawn projectiles, particles, etc. A bone can be
  * used in similar ways, but a PointAttachment is slightly less expensive to compute and can be hidden, shown, and placed in a
  * skin.
- * <p>
- * See <a href="https://esotericsoftware.com/spine-points">Point Attachments</a> in the Spine User Guide. */
+ *
+ * @see https://esotericsoftware.com/spine-points Point Attachments in the Spine User Guide */
 class PointAttachment extends VertexAttachment {
 	public var x:Float = 0;
 	public var y:Float = 0;

spine-haxe/spine-haxe/spine/attachments/RegionAttachment.hx

@@ -32,8 +32,9 @@ package spine.attachments;
 import spine.Color;
 
 /** An attachment that displays a textured quadrilateral.
- * <p>
- * See <a href="https://esotericsoftware.com/spine-regions">Region attachments</a> in the Spine User Guide. */
+ *
+ * @see https://esotericsoftware.com/spine-regions Region attachments in the Spine User Guide
+ */
 class RegionAttachment extends Attachment implements HasTextureRegion {
 	public static inline var BLX:Int = 0;
 	public static inline var BLY:Int = 1;
@@ -64,7 +65,7 @@ class RegionAttachment extends Attachment implements HasTextureRegion {
 	public var region:TextureRegion;
 	public var sequence:Sequence;
 
-	/** For each of the 4 vertices, a pair of <code>x,y</code> values that is the local position of the vertex.
+	/** For each of the 4 vertices, a pair of x,y values that is the local position of the vertex.
 	 * 
 	 * See RegionAttachment.updateRegion(). */
 	private var offsets:Array<Float> = new Array<Float>();
@@ -148,11 +149,10 @@ class RegionAttachment extends Attachment implements HasTextureRegion {
 	/** Transforms the attachment's four vertices to world coordinates. If the attachment has a RegionAttachment.sequence, the region may
 	 * be changed.
 	 * 
-	 * See <a href="https://esotericsoftware.com/spine-runtime-skeletons#World-transforms">World transforms</a> in the Spine
-	 * Runtimes Guide.
-	 * @param worldVertices The output world vertices. Must have a length >= <code>offset</code> + 8.
-	 * @param offset The <code>worldVertices</code> index to begin writing values.
-	 * @param stride The number of <code>worldVertices</code> entries between the value pairs written. */
+	 * @see https://esotericsoftware.com/spine-runtime-skeletons#World-transforms World transforms in the Spine Runtimes Guide
+	 * @param worldVertices The output world vertices. Must have a length >= offset + 8.
+	 * @param offset The worldVertices index to begin writing values.
+	 * @param stride The number of worldVertices entries between the value pairs written. */
 	public function computeWorldVertices(slot:Slot, worldVertices:Array<Float>, offset:Int, stride:Int):Void {
 		if (sequence != null)
 			sequence.apply(slot, this);

spine-haxe/spine-haxe/spine/attachments/VertexAttachment.hx

@@ -62,9 +62,8 @@ class VertexAttachment extends Attachment {
 
 	/** Transforms the attachment's local vertices to world coordinates. If the slot's spine.Slot.deform is
 	 * not empty, it is used to deform the vertices.
-	 * <p>
-	 * See <a href="https://esotericsoftware.com/spine-runtime-skeletons#World-transforms">World transforms</a> in the Spine
-	 * Runtimes Guide.
+	 *
+	 * @see https://esotericsoftware.com/spine-runtime-skeletons#World-transforms World transforms in the Spine Runtimes Guide
 	 * @param start The index of the first vertices value to transform. Each vertex has 2 values, x and y.
 	 * @param count The number of world vertex values to output. Must be <= worldVerticesLength - `start`.
 	 * @param worldVertices The output world vertices. Must have a length >= `offset` + `count` *