simple-pixi-spine 0.1.0

package/dist/types/packages/runtime-4.2/src/core/IkConstraint.d.ts

@@ -0,0 +1,40 @@
+import { Bone } from './Bone.js';
+import { IkConstraintData } from './IkConstraintData.js';
+import { Skeleton } from './Skeleton.js';
+import { Updatable } from './Updatable.js';
+import { Physics } from '@pixi-spine/base';
+/** 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.
+ *
+ * See [IK constraints](http://esotericsoftware.com/spine-ik-constraints) in the Spine User Guide.
+ * @public
+ * */
+export declare class IkConstraint implements Updatable {
+    /** The IK constraint's setup pose data. */
+    data: IkConstraintData;
+    /** The bones that will be modified by this IK constraint. */
+    bones: Array<Bone>;
+    /** The bone that is the IK target. */
+    target: Bone;
+    /** Controls the bend direction of the IK bones, either 1 or -1. */
+    bendDirection: number;
+    /** When true and only a single bone is being constrained, if the target is too close, the bone is scaled to reach it. */
+    compress: boolean;
+    /** When true, if the target is out of range, the parent bone is scaled to reach it. If more than one bone is being constrained
+     * and the parent bone has local nonuniform scale, stretch is not applied. */
+    stretch: boolean;
+    /** A percentage (0-1) that controls the mix between the constrained and unconstrained rotations. */
+    mix: number;
+    /** For two bone IK, the distance from the maximum reach of the bones that rotation will slow. */
+    softness: number;
+    active: boolean;
+    constructor(data: IkConstraintData, skeleton: Skeleton);
+    isActive(): boolean;
+    setToSetupPose(): void;
+    update(physics: Physics): void;
+    /** Applies 1 bone IK. The target is specified in the world coordinate system. */
+    apply1(bone: Bone, targetX: number, targetY: number, compress: boolean, stretch: boolean, uniform: boolean, alpha: number): void;
+    /** Applies 2 bone IK. The target is specified in the world coordinate system.
+     * @param child A direct descendant of the parent bone. */
+    apply2(parent: Bone, child: Bone, targetX: number, targetY: number, bendDir: number, stretch: boolean, uniform: boolean, softness: number, alpha: number): void;
+}

package/dist/types/packages/runtime-4.2/src/core/IkConstraintData.d.ts

@@ -0,0 +1,30 @@
+import { BoneData } from './BoneData.js';
+import { ConstraintData } from './ConstraintData.js';
+/** Stores the setup pose for an {@link IkConstraint}.
+ * <p>
+ * See [IK constraints](http://esotericsoftware.com/spine-ik-constraints) in the Spine User Guide.
+ * @public
+ * */
+export declare class IkConstraintData extends ConstraintData {
+    /** The bones that are constrained by this IK constraint. */
+    bones: BoneData[];
+    /** The bone that is the IK target. */
+    private _target;
+    set target(boneData: BoneData);
+    get target(): BoneData;
+    /** Controls the bend direction of the IK bones, either 1 or -1. */
+    bendDirection: number;
+    /** When true and only a single bone is being constrained, if the target is too close, the bone is scaled to reach it. */
+    compress: boolean;
+    /** When true, if the target is out of range, the parent bone is scaled to reach it. If more than one bone is being constrained
+     * and the parent bone has local nonuniform scale, stretch is not applied. */
+    stretch: boolean;
+    /** When true, only a single bone is being constrained, and {@link #getCompress()} or {@link #getStretch()} is used, the bone
+     * is scaled on both the X and Y axes. */
+    uniform: boolean;
+    /** A percentage (0-1) that controls the mix between the constrained and unconstrained rotations. */
+    mix: number;
+    /** For two bone IK, the distance from the maximum reach of the bones that rotation will slow. */
+    softness: number;
+    constructor(name: string);
+}

package/dist/types/packages/runtime-4.2/src/core/PathConstraint.d.ts

@@ -0,0 +1,47 @@
+import { PathAttachment } from './attachments';
+import { Bone } from './Bone.js';
+import { PathConstraintData } from './PathConstraintData.js';
+import { Skeleton } from './Skeleton.js';
+import { Slot } from './Slot.js';
+import { Updatable } from './Updatable.js';
+import { Physics } from '@pixi-spine/base';
+/** 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}.
+ *
+ * See [Path constraints](http://esotericsoftware.com/spine-path-constraints) in the Spine User Guide.
+ * @public
+ * */
+export declare class PathConstraint implements Updatable {
+    static NONE: number;
+    static BEFORE: number;
+    static AFTER: number;
+    static epsilon: number;
+    /** The path constraint's setup pose data. */
+    data: PathConstraintData;
+    /** The bones that will be modified by this path constraint. */
+    bones: Array<Bone>;
+    /** The slot whose path attachment will be used to constrained the bones. */
+    target: Slot;
+    /** The position along the path. */
+    position: number;
+    /** The spacing between bones. */
+    spacing: number;
+    mixRotate: number;
+    mixX: number;
+    mixY: number;
+    spaces: number[];
+    positions: number[];
+    world: number[];
+    curves: number[];
+    lengths: number[];
+    segments: number[];
+    active: boolean;
+    constructor(data: PathConstraintData, skeleton: Skeleton);
+    isActive(): boolean;
+    setToSetupPose(): void;
+    update(physics: Physics): void;
+    computeWorldPositions(path: PathAttachment, spacesCount: number, tangents: boolean): number[];
+    addBeforePosition(p: number, temp: Array<number>, i: number, out: Array<number>, o: number): void;
+    addAfterPosition(p: number, temp: Array<number>, i: number, out: Array<number>, o: number): void;
+    addCurvePosition(p: number, x1: number, y1: number, cx1: number, cy1: number, cx2: number, cy2: number, x2: number, y2: number, out: Array<number>, o: number, tangents: boolean): void;
+}

package/dist/types/packages/runtime-4.2/src/core/PathConstraintData.d.ts

@@ -0,0 +1,62 @@
+import { BoneData } from './BoneData.js';
+import { ConstraintData } from './ConstraintData.js';
+import { SlotData } from './SlotData.js';
+/** Stores the setup pose for a {@link PathConstraint}.
+ *
+ * See [path constraints](http://esotericsoftware.com/spine-path-constraints) in the Spine User Guide.
+ * @public
+ * */
+export declare class PathConstraintData extends ConstraintData {
+    /** The bones that will be modified by this path constraint. */
+    bones: BoneData[];
+    /** The slot whose path attachment will be used to constrained the bones. */
+    private _target;
+    set target(slotData: SlotData);
+    get target(): SlotData;
+    /** The mode for positioning the first bone on the path. */
+    positionMode: PositionMode;
+    /** The mode for positioning the bones after the first bone on the path. */
+    spacingMode: SpacingMode;
+    /** The mode for adjusting the rotation of the bones. */
+    rotateMode: RotateMode;
+    /** An offset added to the constrained bone rotation. */
+    offsetRotation: number;
+    /** The position along the path. */
+    position: number;
+    /** The spacing between bones. */
+    spacing: number;
+    mixRotate: number;
+    mixX: number;
+    mixY: number;
+    constructor(name: string);
+}
+/** Controls how the first bone is positioned along the path.
+ *
+ * See [position](http://esotericsoftware.com/spine-path-constraints#Position) in the Spine User Guide.
+ * @public
+ * */
+export declare enum PositionMode {
+    Fixed = 0,
+    Percent = 1
+}
+/** Controls how bones after the first bone are positioned along the path.
+ *
+ * See [spacing](http://esotericsoftware.com/spine-path-constraints#Spacing) in the Spine User Guide.
+ * @public
+ * */
+export declare enum SpacingMode {
+    Length = 0,
+    Fixed = 1,
+    Percent = 2,
+    Proportional = 3
+}
+/** Controls how bones are rotated, translated, and scaled to match the path.
+ *
+ * See [rotate mix](http://esotericsoftware.com/spine-path-constraints#Rotate-mix) in the Spine User Guide.
+ * @public
+ * */
+export declare enum RotateMode {
+    Tangent = 0,
+    Chain = 1,
+    ChainScale = 2
+}

package/dist/types/packages/runtime-4.2/src/core/PhysicsConstraint.d.ts

@@ -0,0 +1,54 @@
+import { Bone } from './Bone.js';
+import { PhysicsConstraintData } from './PhysicsConstraintData.js';
+import { Skeleton } from './Skeleton.js';
+import { Updatable } from './Updatable.js';
+import { Physics } from '@pixi-spine/base';
+/** Stores the current pose for a physics constraint. A physics constraint applies physics to bones.
+ *
+ * See <a href="http://esotericsoftware.com/spine-physics-constraints">Physics constraints</a> in the Spine User Guide.
+ * @public
+ * */
+export declare class PhysicsConstraint implements Updatable {
+    readonly data: PhysicsConstraintData;
+    private _bone;
+    set bone(bone: Bone);
+    get bone(): Bone;
+    inertia: number;
+    strength: number;
+    damping: number;
+    massInverse: number;
+    wind: number;
+    gravity: number;
+    mix: number;
+    _reset: boolean;
+    ux: number;
+    uy: number;
+    cx: number;
+    cy: number;
+    tx: number;
+    ty: number;
+    xOffset: number;
+    xVelocity: number;
+    yOffset: number;
+    yVelocity: number;
+    rotateOffset: number;
+    rotateVelocity: number;
+    scaleOffset: number;
+    scaleVelocity: number;
+    active: boolean;
+    readonly skeleton: Skeleton;
+    remaining: number;
+    lastTime: number;
+    constructor(data: PhysicsConstraintData, skeleton: Skeleton);
+    reset(): void;
+    setToSetupPose(): void;
+    isActive(): boolean;
+    /** Applies the constraint to the constrained bones. */
+    update(physics: Physics): void;
+    /** Translates the physics constraint so next {@link #update(Physics)} forces are applied as if the bone moved an additional
+     * amount in world space. */
+    translate(x: number, y: number): void;
+    /** Rotates the physics constraint so next {@link #update(Physics)} forces are applied as if the bone rotated around the
+     * specified point in world space. */
+    rotate(x: number, y: number, degrees: number): void;
+}

package/dist/types/packages/runtime-4.2/src/core/PhysicsConstraintData.d.ts

@@ -0,0 +1,35 @@
+import { BoneData } from './BoneData.js';
+import { ConstraintData } from './ConstraintData.js';
+/** Stores the setup pose for a {@link PhysicsConstraint}.
+ * <p>
+ * See <a href="http://esotericsoftware.com/spine-physics-constraints">Physics constraints</a> in the Spine User Guide.
+ * @public
+ * */
+export declare class PhysicsConstraintData extends ConstraintData {
+    private _bone;
+    set bone(boneData: BoneData);
+    get bone(): BoneData;
+    x: number;
+    y: number;
+    rotate: number;
+    scaleX: number;
+    shearX: number;
+    limit: number;
+    step: number;
+    inertia: number;
+    strength: number;
+    damping: number;
+    massInverse: number;
+    wind: number;
+    gravity: number;
+    /** A percentage (0-1) that controls the mix between the constrained and unconstrained poses. */
+    mix: number;
+    inertiaGlobal: boolean;
+    strengthGlobal: boolean;
+    dampingGlobal: boolean;
+    massGlobal: boolean;
+    windGlobal: boolean;
+    gravityGlobal: boolean;
+    mixGlobal: boolean;
+    constructor(name: string);
+}

package/dist/types/packages/runtime-4.2/src/core/Skeleton.d.ts

@@ -0,0 +1,160 @@
+import { Attachment } from './attachments';
+import { Bone } from './Bone.js';
+import { IkConstraint } from './IkConstraint.js';
+import { PathConstraint } from './PathConstraint.js';
+import { PhysicsConstraint } from './PhysicsConstraint.js';
+import { SkeletonClipping } from './SkeletonClipping.js';
+import { SkeletonData } from './SkeletonData.js';
+import { Skin } from './Skin.js';
+import { Slot } from './Slot.js';
+import { TransformConstraint } from './TransformConstraint.js';
+import { Updatable } from './Updatable.js';
+import { Color, ISkeleton, Physics, Vector2 } from '@pixi-spine/base';
+/** Stores the current pose for a skeleton.
+ *
+ * See [Instance objects](http://esotericsoftware.com/spine-runtime-architecture#Instance-objects) in the Spine Runtimes Guide.
+ * @public
+ * */
+export declare class Skeleton implements ISkeleton<SkeletonData, Bone, Slot, Skin> {
+    private static quadTriangles;
+    static yDown: boolean;
+    /** The skeleton's setup pose data. */
+    data: SkeletonData;
+    /** The skeleton's bones, sorted parent first. The root bone is always the first bone. */
+    bones: Array<Bone>;
+    /** The skeleton's slots in the setup pose draw order. */
+    slots: Array<Slot>;
+    /** The skeleton's slots in the order they should be drawn. The returned array may be modified to change the draw order. */
+    drawOrder: Array<Slot>;
+    /** The skeleton's IK constraints. */
+    ikConstraints: Array<IkConstraint>;
+    /** The skeleton's transform constraints. */
+    transformConstraints: Array<TransformConstraint>;
+    /** The skeleton's path constraints. */
+    pathConstraints: Array<PathConstraint>;
+    /** The skeleton's physics constraints. */
+    physicsConstraints: Array<PhysicsConstraint>;
+    /** The list of bones and constraints, sorted in the order they should be updated, as computed by {@link #updateCache()}. */
+    _updateCache: Updatable[];
+    /** The skeleton's current skin. May be null. */
+    skin: Skin | null;
+    /** The color to tint all the skeleton's attachments. */
+    color: Color;
+    /** Scales the entire skeleton on the X axis. This affects all bones, even if the bone's transform mode disallows scale
+     * inheritance. */
+    scaleX: number;
+    /** Scales the entire skeleton on the Y axis. This affects all bones, even if the bone's transform mode disallows scale
+     * inheritance. */
+    private _scaleY;
+    get scaleY(): number;
+    set scaleY(scaleY: number);
+    /** Sets the skeleton X position, which is added to the root bone worldX position. */
+    x: number;
+    /** Sets the skeleton Y position, which is added to the root bone worldY position. */
+    y: number;
+    /** Returns the skeleton's time. This is used for time-based manipulations, such as {@link PhysicsConstraint}.
+     * <p>
+     * See {@link #update(float)}. */
+    time: number;
+    constructor(data: SkeletonData);
+    /** Caches information about bones and constraints. Must be called if the {@link #getSkin()} is modified or if bones,
+     * constraints, or weighted path attachments are added or removed. */
+    updateCache(): void;
+    sortIkConstraint(constraint: IkConstraint): void;
+    sortPathConstraint(constraint: PathConstraint): void;
+    sortTransformConstraint(constraint: TransformConstraint): void;
+    sortPathConstraintAttachment(skin: Skin, slotIndex: number, slotBone: Bone): void;
+    sortPathConstraintAttachmentWith(attachment: Attachment, slotBone: Bone): void;
+    sortPhysicsConstraint(constraint: PhysicsConstraint): void;
+    sortBone(bone: Bone): void;
+    sortReset(bones: Array<Bone>): void;
+    /** Updates the world transform for each bone and applies all constraints.
+     *
+     * See [World transforms](http://esotericsoftware.com/spine-runtime-skeletons#World-transforms) in the Spine
+     * Runtimes Guide. */
+    updateWorldTransform(physics: Physics): void;
+    updateWorldTransformWith(physics: Physics, parent: Bone): void;
+    /** Sets the bones, constraints, and slots to their setup pose values. */
+    setToSetupPose(): void;
+    /** Sets the bones and constraints to their setup pose values. */
+    setBonesToSetupPose(): void;
+    /** Sets the slots and draw order to their setup pose values. */
+    setSlotsToSetupPose(): void;
+    /** @returns May return null. */
+    getRootBone(): Bone;
+    /** @returns May be null. */
+    findBone(boneName: string): Bone;
+    /** @returns -1 if the bone was not found. */
+    findBoneIndex(boneName: string): number;
+    /** Finds a slot by comparing each slot's name. It is more efficient to cache the results of this method than to call it
+     * repeatedly.
+     * @returns May be null. */
+    findSlot(slotName: string): Slot;
+    /** @returns -1 if the bone was not found. */
+    findSlotIndex(slotName: string): number;
+    /** Sets a skin by name.
+     *
+     * See {@link #setSkin()}. */
+    setSkinByName(skinName: string): void;
+    /** Sets the skin used to look up attachments before looking in the {@link SkeletonData#defaultSkin default skin}. If the
+     * skin is changed, {@link #updateCache()} is called.
+     *
+     * 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.
+     *
+     * After changing the skin, the visible attachments can be reset to those attached in the setup pose by calling
+     * {@link #setSlotsToSetupPose()}. Also, often {@link 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 skin.
+     * @param newSkin May be null. */
+    setSkin(newSkin: Skin): void;
+    /** Finds an attachment by looking in the {@link #skin} and {@link SkeletonData#defaultSkin} using the slot name and attachment
+     * name.
+     *
+     * See {@link #getAttachment()}.
+     * @returns May be null. */
+    getAttachmentByName(slotName: string, attachmentName: string): Attachment | null;
+    /** Finds an attachment by looking in the {@link #skin} and {@link 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.
+     *
+     * See [Runtime skins](http://esotericsoftware.com/spine-runtime-skins) in the Spine Runtimes Guide.
+     * @returns May be null. */
+    getAttachment(slotIndex: number, attachmentName: string): Attachment | null;
+    /** A convenience method to set an attachment by finding the slot with {@link #findSlot()}, finding the attachment with
+     * {@link #getAttachment()}, then setting the slot's {@link Slot#attachment}.
+     * @param attachmentName May be null to clear the slot's attachment. */
+    setAttachment(slotName: string, attachmentName: string): void;
+    /** Finds an IK constraint by comparing each IK constraint's name. It is more efficient to cache the results of this method
+     * than to call it repeatedly.
+     * @return May be null. */
+    findIkConstraint(constraintName: string): IkConstraint;
+    /** Finds a transform constraint by comparing each transform constraint's name. It is more efficient to cache the results of
+     * this method than to call it repeatedly.
+     * @return May be null. */
+    findTransformConstraint(constraintName: string): TransformConstraint;
+    /** Finds a path constraint by comparing each path constraint's name. It is more efficient to cache the results of this method
+     * than to call it repeatedly.
+     * @return May be null. */
+    findPathConstraint(constraintName: string): PathConstraint;
+    /** Finds a physics constraint by comparing each physics constraint's name. It is more efficient to cache the results of this
+     * method than to call it repeatedly. */
+    findPhysicsConstraint(constraintName: string): PhysicsConstraint;
+    /** Returns the axis aligned bounding box (AABB) of the region and mesh attachments for the current pose as `{ x: number, y: number, width: number, height: number }`.
+     * Note that this method will create temporary objects which can add to garbage collection pressure. Use `getBounds()` if garbage collection is a concern. */
+    getBoundsRect(): {
+        x: number;
+        y: number;
+        width: number;
+        height: number;
+    };
+    /** Returns the axis aligned bounding box (AABB) of the region and mesh attachments for the current pose.
+     * @param offset An output value, the distance from the skeleton origin to the bottom left corner of the AABB.
+     * @param size An output value, the width and height of the AABB.
+     * @param temp Working memory to temporarily store attachments' computed world vertices.
+     * @param clipper {@link SkeletonClipping} to use. If <code>null</code>, no clipping is applied. */
+    getBounds(offset: Vector2, size: Vector2, temp?: Array<number>, clipper?: SkeletonClipping | null): void;
+    /** Increments the skeleton's {@link #time}. */
+    update(delta: number): void;
+    physicsTranslate(x: number, y: number): void;
+    /** Calls {@link PhysicsConstraint#rotate(float, float, float)} for each physics constraint. */
+    physicsRotate(x: number, y: number, degrees: number): void;
+}

package/dist/types/packages/runtime-4.2/src/core/SkeletonBinary.d.ts

@@ -0,0 +1,43 @@
+import { AttachmentLoader } from './attachments/AttachmentLoader.js';
+import { SkeletonData } from './SkeletonData.js';
+/** Loads skeleton data in the Spine binary format.
+ * @public
+ * See [Spine binary format](http://esotericsoftware.com/spine-binary-format) and
+ * [JSON and binary data](http://esotericsoftware.com/spine-loading-skeleton-data#JSON-and-binary-data) in the Spine
+ * Runtimes Guide. */
+export declare class SkeletonBinary {
+    /** Scales bone positions, image sizes, and translations as they are loaded. This allows different size images to be used at
+     * runtime than were used in Spine.
+     *
+     * See [Scaling](http://esotericsoftware.com/spine-loading-skeleton-data#Scaling) in the Spine Runtimes Guide. */
+    scale: number;
+    attachmentLoader: AttachmentLoader;
+    private linkedMeshes;
+    constructor(attachmentLoader: AttachmentLoader);
+    readSkeletonData(binary: Uint8Array | ArrayBuffer): SkeletonData;
+    private readSkin;
+    private readAttachment;
+    private readSequence;
+    private readVertices;
+    private readFloatArray;
+    private readShortArray;
+    private readAnimation;
+}
+/**
+ * @public
+ * */
+export declare class BinaryInput {
+    strings: string[];
+    private index;
+    private buffer;
+    constructor(data: Uint8Array | ArrayBuffer, strings?: string[], index?: number, buffer?: DataView);
+    readByte(): number;
+    readUnsignedByte(): number;
+    readShort(): number;
+    readInt32(): number;
+    readInt(optimizePositive: boolean): number;
+    readStringRef(): string | null;
+    readString(): string | null;
+    readFloat(): number;
+    readBoolean(): boolean;
+}

package/dist/types/packages/runtime-4.2/src/core/SkeletonBounds.d.ts

@@ -0,0 +1,51 @@
+import { BoundingBoxAttachment } from './attachments/BoundingBoxAttachment.js';
+import { Skeleton } from './Skeleton.js';
+import { NumberArrayLike } from '@pixi-spine/base';
+/** Collects each visible {@link BoundingBoxAttachment} and computes the world vertices for its polygon. The polygon vertices are
+ * provided along with convenience methods for doing hit detection.
+ * @public
+ * */
+export declare class SkeletonBounds {
+    /** The left edge of the axis aligned bounding box. */
+    minX: number;
+    /** The bottom edge of the axis aligned bounding box. */
+    minY: number;
+    /** The right edge of the axis aligned bounding box. */
+    maxX: number;
+    /** The top edge of the axis aligned bounding box. */
+    maxY: number;
+    /** The visible bounding boxes. */
+    boundingBoxes: BoundingBoxAttachment[];
+    /** The world vertices for the bounding box polygons. */
+    polygons: NumberArrayLike[];
+    private polygonPool;
+    /** Clears any previous polygons, finds all visible bounding box attachments, and computes the world vertices for each bounding
+     * box's polygon.
+     * @param updateAabb If true, the axis aligned bounding box containing all the polygons is computed. If false, the
+     *           SkeletonBounds AABB methods will always return true. */
+    update(skeleton: Skeleton, updateAabb: boolean): void;
+    aabbCompute(): void;
+    /** Returns true if the axis aligned bounding box contains the point. */
+    aabbContainsPoint(x: number, y: number): boolean;
+    /** Returns true if the axis aligned bounding box intersects the line segment. */
+    aabbIntersectsSegment(x1: number, y1: number, x2: number, y2: number): boolean;
+    /** Returns true if the axis aligned bounding box intersects the axis aligned bounding box of the specified bounds. */
+    aabbIntersectsSkeleton(bounds: SkeletonBounds): boolean;
+    /** Returns the first bounding box attachment that contains the point, or null. When doing many checks, it is usually more
+     * efficient to only call this method if {@link #aabbContainsPoint(float, float)} returns true. */
+    containsPoint(x: number, y: number): BoundingBoxAttachment | null;
+    /** Returns true if the polygon contains the point. */
+    containsPointPolygon(polygon: NumberArrayLike, x: number, y: number): boolean;
+    /** Returns the first bounding box attachment that contains any part of the line segment, or null. When doing many checks, it
+     * is usually more efficient to only call this method if {@link #aabbIntersectsSegment()} returns
+     * true. */
+    intersectsSegment(x1: number, y1: number, x2: number, y2: number): BoundingBoxAttachment;
+    /** Returns true if the polygon contains any part of the line segment. */
+    intersectsSegmentPolygon(polygon: NumberArrayLike, x1: number, y1: number, x2: number, y2: number): boolean;
+    /** Returns the polygon for the specified bounding box, or null. */
+    getPolygon(boundingBox: BoundingBoxAttachment): NumberArrayLike;
+    /** The width of the axis aligned bounding box. */
+    getWidth(): number;
+    /** The height of the axis aligned bounding box. */
+    getHeight(): number;
+}

package/dist/types/packages/runtime-4.2/src/core/SkeletonClipping.d.ts

@@ -0,0 +1,38 @@
+import { ClippingAttachment } from './attachments';
+import { Slot } from './Slot.js';
+import { Color, NumberArrayLike } from '@pixi-spine/base';
+/**
+ * @public
+ */
+export declare class SkeletonClipping {
+    private triangulator;
+    private clippingPolygon;
+    private clipOutput;
+    clippedVertices: number[];
+    clippedUVs: number[];
+    clippedTriangles: number[];
+    private scratch;
+    private clipAttachment;
+    private clippingPolygons;
+    clipStart(slot: Slot, clip: ClippingAttachment): number;
+    clipEndWithSlot(slot: Slot): void;
+    clipEnd(): void;
+    isClipping(): boolean;
+    /**
+     * @deprecated Use clipTriangles without verticesLength parameter. Mark for removal in 4.3.
+     */
+    clipTriangles(vertices: NumberArrayLike, verticesLength: number, triangles: NumberArrayLike, trianglesLength: number): void;
+    /**
+     * @deprecated Use clipTriangles without verticesLength parameter. Mark for removal in 4.3.
+     */
+    clipTriangles(vertices: NumberArrayLike, verticesLength: number, triangles: NumberArrayLike, trianglesLength: number, uvs: NumberArrayLike, light: Color, dark: Color, twoColor: boolean): void;
+    clipTriangles(vertices: NumberArrayLike, triangles: NumberArrayLike, trianglesLength: number): void;
+    clipTriangles(vertices: NumberArrayLike, triangles: NumberArrayLike, trianglesLength: number, uvs: NumberArrayLike, light: Color, dark: Color, twoColor: boolean): void;
+    private clipTrianglesNoRender;
+    private clipTrianglesRender;
+    clipTrianglesUnpacked(vertices: NumberArrayLike, triangles: NumberArrayLike, trianglesLength: number, uvs: NumberArrayLike): void;
+    /** Clips the input triangle against the convex, clockwise clipping area. If the triangle lies entirely within the clipping
+     * area, false is returned. The clipping area must duplicate the first vertex at the end of the vertices list. */
+    clip(x1: number, y1: number, x2: number, y2: number, x3: number, y3: number, clippingArea: Array<number>, output: Array<number>): boolean;
+    static makeClockwise(polygon: NumberArrayLike): void;
+}