@flighthq/skeleton2d 0.5.1-next.973.788d3d7 → 0.6.0

package/dist/Skeleton2DAnimationPath.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"Skeleton2DAnimationPath.js","sourceRoot":"","sources":["../src/Skeleton2DAnimationPath.ts"],"names":[],"mappings":"AAAA,sGAAsG;AACtG,mGAAmG;AACnG,yGAAyG;AACzG,iBAAiB;AACjB,EAAE;AACF,yEAAyE;AACzE,wEAAwE;AACxE,yEAAyE;AACzE,yEAAyE;AACzE,EAAE;AACF,qGAAqG;AACrG,wGAAwG;AACxG,kGAAkG;AAClG,wGAAwG;AACxG,wBAAwB;AACxB,EAAE;AACF,sFAAsF;AACtF,sFAAsF;AACtF,sFAAsF;AACtF,EAAE;AACF,sGAAsG;AACtG,sGAAsG;AACtG,+BAA+B;AAC/B,EAAE;AACF,yGAAyG;AACzG,sGAAsG;AACtG,uGAAuG;AACvG,uGAAuG;AACvG,wGAAwG;AACxG,0GAA0G;AAC1G,EAAE;AACF,2GAA2G;AAC3G,yGAAyG;AACzG,yGAAyG;AACzG,2DAA2D;AAC3D,MAAM,CAAC,MAAM,uBAAuB,GAAG;IACrC,WAAW,EAAE,aAAa;IAC1B,YAAY,EAAE,cAAc;IAC5B,YAAY,EAAE,cAAc;IAC5B,QAAQ,EAAE,UAAU;IACpB,KAAK,EAAE,OAAO;IACd,MAAM,EAAE,QAAQ;IAChB,MAAM,EAAE,QAAQ;IAChB,KAAK,EAAE,OAAO;IACd,MAAM,EAAE,QAAQ;IAChB,MAAM,EAAE,QAAQ;CACR,CAAC"}

package/dist/Skeleton2DAnimationTargetBinder.d.ts

@@ -0,0 +1,14 @@
+import type { AnimationChannel } from '@flighthq/animation/contract';
+import type { Skeleton2D } from './Skeleton2DContract.ts';
+/**
+ * What one target kind does with a channel. `applyAnimationClipToSkeleton2D` looks the channel's target
+ * kind up in the binder registry and hands the whole channel over, so a family this package does not own
+ * poses through the same single pass as bones and slots.
+ *
+ * `target` is the channel's `targetRef`, already known to carry the kind the binder registered for; a
+ * binder casts it to its own target type. `setup` is the immutable rest pose and `pose` is what gets
+ * written — they are never the same object. A binder that cannot use what it is given returns without
+ * writing, because a channel it cannot honor is an expected condition rather than an error.
+ */
+export type Skeleton2DAnimationTargetBinder = (channel: Readonly<AnimationChannel>, setup: Readonly<Skeleton2D>, pose: Skeleton2D, target: unknown, time: number) => void;
+//# sourceMappingURL=Skeleton2DAnimationTargetBinder.d.ts.map

package/dist/Skeleton2DAnimationTargetBinder.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"Skeleton2DAnimationTargetBinder.d.ts","sourceRoot":"","sources":["../src/Skeleton2DAnimationTargetBinder.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,gBAAgB,EAAE,MAAM,8BAA8B,CAAC;AAErE,OAAO,KAAK,EAAE,UAAU,EAAE,MAAM,yBAAyB,CAAC;AAE1D;;;;;;;;;GASG;AACH,MAAM,MAAM,+BAA+B,GAAG,CAC5C,OAAO,EAAE,QAAQ,CAAC,gBAAgB,CAAC,EACnC,KAAK,EAAE,QAAQ,CAAC,UAAU,CAAC,EAC3B,IAAI,EAAE,UAAU,EAChB,MAAM,EAAE,OAAO,EACf,IAAI,EAAE,MAAM,KACT,IAAI,CAAC"}

package/dist/Skeleton2DAnimationTargetBinder.js

@@ -0,0 +1,2 @@
+export {};
+//# sourceMappingURL=Skeleton2DAnimationTargetBinder.js.map

package/dist/Skeleton2DAnimationTargetBinder.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"Skeleton2DAnimationTargetBinder.js","sourceRoot":"","sources":["../src/Skeleton2DAnimationTargetBinder.ts"],"names":[],"mappings":""}

package/dist/Skeleton2DAnimationTargetContract.d.ts

@@ -0,0 +1,9 @@
+import type { Entity } from '@flighthq/entity/contract';
+import type { Skeleton2DAnimationPath } from './Skeleton2DAnimationPath.ts';
+import type { Skeleton2DAnimationTargetKind } from './Skeleton2DAnimationTargetKind.ts';
+export interface Skeleton2DAnimationTarget extends Entity {
+    boneIndex: number;
+    kind: Skeleton2DAnimationTargetKind;
+    path: Skeleton2DAnimationPath;
+}
+//# sourceMappingURL=Skeleton2DAnimationTargetContract.d.ts.map

package/dist/Skeleton2DAnimationTargetContract.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"Skeleton2DAnimationTargetContract.d.ts","sourceRoot":"","sources":["../src/Skeleton2DAnimationTargetContract.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,MAAM,EAAE,MAAM,2BAA2B,CAAC;AAExD,OAAO,KAAK,EAAE,uBAAuB,EAAE,MAAM,8BAA8B,CAAC;AAC5E,OAAO,KAAK,EAAE,6BAA6B,EAAE,MAAM,oCAAoC,CAAC;AAUxF,MAAM,WAAW,yBAA0B,SAAQ,MAAM;IACvD,SAAS,EAAE,MAAM,CAAC;IAClB,IAAI,EAAE,6BAA6B,CAAC;IACpC,IAAI,EAAE,uBAAuB,CAAC;CAC/B"}

package/dist/Skeleton2DAnimationTargetContract.js

@@ -0,0 +1,2 @@
+export {};
+//# sourceMappingURL=Skeleton2DAnimationTargetContract.js.map

package/dist/Skeleton2DAnimationTargetContract.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"Skeleton2DAnimationTargetContract.js","sourceRoot":"","sources":["../src/Skeleton2DAnimationTargetContract.ts"],"names":[],"mappings":""}

package/dist/Skeleton2DAnimationTargetKind.d.ts

@@ -0,0 +1,9 @@
+export declare const Skeleton2DAnimationTargetKind: {
+    readonly Bone: 'Skeleton2D.BoneTarget';
+    readonly Constraint: 'Skeleton2D.ConstraintTarget';
+    readonly Deform: 'Skeleton2D.DeformTarget';
+    readonly DrawOrder: 'Skeleton2D.DrawOrderTarget';
+    readonly Slot: 'Skeleton2D.SlotTarget';
+};
+export type Skeleton2DAnimationTargetKind = string;
+//# sourceMappingURL=Skeleton2DAnimationTargetKind.d.ts.map

package/dist/Skeleton2DAnimationTargetKind.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"Skeleton2DAnimationTargetKind.d.ts","sourceRoot":"","sources":["../src/Skeleton2DAnimationTargetKind.ts"],"names":[],"mappings":"AAYA,eAAO,MAAM,6BAA6B;aACxC,IAAI,EAAE,uBAAuB;aAC7B,UAAU,EAAE,6BAA6B;aACzC,MAAM,EAAE,yBAAyB;aACjC,SAAS,EAAE,4BAA4B;aACvC,IAAI,EAAE,uBAAuB;CACrB,CAAC;AAEX,MAAM,MAAM,6BAA6B,GAAG,MAAM,CAAC"}

package/dist/Skeleton2DAnimationTargetKind.js

@@ -0,0 +1,20 @@
+// Which family of a Skeleton2D an AnimationChannel's target addresses. It is the registry key
+// `applyAnimationClipToSkeleton2D` dispatches on, exactly as a `*Kind` keys a renderer, an effect runner or
+// a decompressor — a plain string, so the key, the serialized form and the vocabulary are one value.
+//
+// The kind exists because the family is OPEN and already large. The two 2D-skeletal formats animate eight
+// things that are not bone transforms — slot attachment, slot colour, IK, transform, path, deform, draw
+// order and event — and both binary parsers already walk every one of those records. Dispatching on target
+// SHAPE (`typeof target.boneIndex === 'number'`) is legible for two families and an order-dependent probe
+// at eight, where adding one target whose fields happen to overlap another silently reroutes it.
+//
+// A third-party target carries a vendor-prefixed kind (`'acme.RopeTarget'`) and registers its own binder,
+// so an unused family costs a consumer nothing.
+export const Skeleton2DAnimationTargetKind = {
+    Bone: 'Skeleton2D.BoneTarget',
+    Constraint: 'Skeleton2D.ConstraintTarget',
+    Deform: 'Skeleton2D.DeformTarget',
+    DrawOrder: 'Skeleton2D.DrawOrderTarget',
+    Slot: 'Skeleton2D.SlotTarget',
+};
+//# sourceMappingURL=Skeleton2DAnimationTargetKind.js.map

package/dist/Skeleton2DAnimationTargetKind.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"Skeleton2DAnimationTargetKind.js","sourceRoot":"","sources":["../src/Skeleton2DAnimationTargetKind.ts"],"names":[],"mappings":"AAAA,8FAA8F;AAC9F,4GAA4G;AAC5G,qGAAqG;AACrG,EAAE;AACF,0GAA0G;AAC1G,wGAAwG;AACxG,2GAA2G;AAC3G,0GAA0G;AAC1G,iGAAiG;AACjG,EAAE;AACF,0GAA0G;AAC1G,gDAAgD;AAChD,MAAM,CAAC,MAAM,6BAA6B,GAAG;IAC3C,IAAI,EAAE,uBAAuB;IAC7B,UAAU,EAAE,6BAA6B;IACzC,MAAM,EAAE,yBAAyB;IACjC,SAAS,EAAE,4BAA4B;IACvC,IAAI,EAAE,uBAAuB;CACrB,CAAC"}

package/dist/Skeleton2DConstraintContract.d.ts

@@ -0,0 +1,37 @@
+import type { Entity } from '@flighthq/entity/contract';
+import type { Skeleton2D } from './Skeleton2DContract.ts';
+/**
+ * A pose rule applied after the bones are placed and before they are drawn — inverse kinematics, transform
+ * copying, and later path following. Constraints are plain data carrying a `kind`, and a solver is
+ * registered against that kind, so a rig that uses only IK never bundles the others.
+ *
+ * `mix` is the blend from the unconstrained pose to the solved one: 0 leaves the bone exactly as animation
+ * posed it, 1 applies the constraint fully. It is the field that lets a constraint be faded in and out by
+ * an animation rather than being all-or-nothing, which is how both Spine and DragonBones author them.
+ */
+export interface Skeleton2DConstraint extends Entity {
+    kind: Skeleton2DConstraintKind;
+    mix: number;
+}
+/**
+ * What solves a constraint. `solveSkeleton2DConstraints` looks the kind up and hands the whole constraint
+ * over, so a family this package does not own solves in the same pass as the built-in ones.
+ *
+ * A solver READS `skeleton.worldMatrices` (the caller must have filled them) and WRITES bone LOCAL
+ * transforms, then refreshes the world matrices of the bones it moved so a later constraint in the same
+ * pass sees them. It does not propagate to descendants — the caller re-runs
+ * `computeSkeleton2DWorldTransforms` once after the whole pass, which is one walk rather than one per
+ * constraint.
+ */
+export type Skeleton2DConstraintSolver = (skeleton: Skeleton2D, constraint: Readonly<Skeleton2DConstraint>) => void;
+/**
+ * The registry key for a constraint family, on the same terms as every other `*Kind` in the SDK: a plain
+ * string, PascalCase, vendor-prefixed when it is not Flight's own.
+ */
+export declare const Skeleton2DConstraintKind: {
+    readonly Ik: 'Skeleton2D.IkConstraint';
+    readonly Path: 'Skeleton2D.PathConstraint';
+    readonly Transform: 'Skeleton2D.TransformConstraint';
+};
+export type Skeleton2DConstraintKind = string;
+//# sourceMappingURL=Skeleton2DConstraintContract.d.ts.map

package/dist/Skeleton2DConstraintContract.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"Skeleton2DConstraintContract.d.ts","sourceRoot":"","sources":["../src/Skeleton2DConstraintContract.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,MAAM,EAAE,MAAM,2BAA2B,CAAC;AAExD,OAAO,KAAK,EAAE,UAAU,EAAE,MAAM,yBAAyB,CAAC;AAE1D;;;;;;;;GAQG;AACH,MAAM,WAAW,oBAAqB,SAAQ,MAAM;IAClD,IAAI,EAAE,wBAAwB,CAAC;IAC/B,GAAG,EAAE,MAAM,CAAC;CACb;AAED;;;;;;;;;GASG;AACH,MAAM,MAAM,0BAA0B,GAAG,CAAC,QAAQ,EAAE,UAAU,EAAE,UAAU,EAAE,QAAQ,CAAC,oBAAoB,CAAC,KAAK,IAAI,CAAC;AAEpH;;;GAGG;AACH,eAAO,MAAM,wBAAwB;aACnC,EAAE,EAAE,yBAAyB;aAC7B,IAAI,EAAE,2BAA2B;aACjC,SAAS,EAAE,gCAAgC;CACnC,CAAC;AAEX,MAAM,MAAM,wBAAwB,GAAG,MAAM,CAAC"}

package/dist/Skeleton2DConstraintContract.js

@@ -0,0 +1,10 @@
+/**
+ * The registry key for a constraint family, on the same terms as every other `*Kind` in the SDK: a plain
+ * string, PascalCase, vendor-prefixed when it is not Flight's own.
+ */
+export const Skeleton2DConstraintKind = {
+    Ik: 'Skeleton2D.IkConstraint',
+    Path: 'Skeleton2D.PathConstraint',
+    Transform: 'Skeleton2D.TransformConstraint',
+};
+//# sourceMappingURL=Skeleton2DConstraintContract.js.map

package/dist/Skeleton2DConstraintContract.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"Skeleton2DConstraintContract.js","sourceRoot":"","sources":["../src/Skeleton2DConstraintContract.ts"],"names":[],"mappings":"AA8BA;;;GAGG;AACH,MAAM,CAAC,MAAM,wBAAwB,GAAG;IACtC,EAAE,EAAE,yBAAyB;IAC7B,IAAI,EAAE,2BAA2B;IACjC,SAAS,EAAE,gCAAgC;CACnC,CAAC"}

package/dist/Skeleton2DContract.d.ts

@@ -0,0 +1,13 @@
+import type { Entity } from '@flighthq/entity/contract';
+import type { AttachmentSkin2D } from './AttachmentSkin2D.ts';
+import type { Bone2D } from './Bone2D.ts';
+import type { Slot2D } from './Slot2D.ts';
+export interface Skeleton2D extends Entity {
+    boneMatrices: Float32Array;
+    bones: Bone2D[];
+    inverseBindMatrices: Float32Array;
+    skins?: AttachmentSkin2D[] | null;
+    slots?: Slot2D[] | null;
+    worldMatrices: Float32Array;
+}
+//# sourceMappingURL=Skeleton2DContract.d.ts.map

package/dist/Skeleton2DContract.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"Skeleton2DContract.d.ts","sourceRoot":"","sources":["../src/Skeleton2DContract.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,MAAM,EAAE,MAAM,2BAA2B,CAAC;AAExD,OAAO,KAAK,EAAE,gBAAgB,EAAE,MAAM,uBAAuB,CAAC;AAC9D,OAAO,KAAK,EAAE,MAAM,EAAE,MAAM,aAAa,CAAC;AAC1C,OAAO,KAAK,EAAE,MAAM,EAAE,MAAM,aAAa,CAAC;AAsB1C,MAAM,WAAW,UAAW,SAAQ,MAAM;IACxC,YAAY,EAAE,YAAY,CAAC;IAC3B,KAAK,EAAE,MAAM,EAAE,CAAC;IAChB,mBAAmB,EAAE,YAAY,CAAC;IAClC,KAAK,CAAC,EAAE,gBAAgB,EAAE,GAAG,IAAI,CAAC;IAClC,KAAK,CAAC,EAAE,MAAM,EAAE,GAAG,IAAI,CAAC;IACxB,aAAa,EAAE,YAAY,CAAC;CAC7B"}

package/dist/Skeleton2DContract.js

@@ -0,0 +1,2 @@
+export {};
+//# sourceMappingURL=Skeleton2DContract.js.map

package/dist/Skeleton2DContract.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"Skeleton2DContract.js","sourceRoot":"","sources":["../src/Skeleton2DContract.ts"],"names":[],"mappings":""}

package/dist/Skeleton2DDeformAnimationTarget.d.ts

@@ -0,0 +1,22 @@
+import type { Attachment2D } from './Attachment2D.ts';
+import type { Skeleton2DAnimationTargetKind } from './Skeleton2DAnimationTargetKind.ts';
+/**
+ * The binding target for a channel that animates an attachment's per-vertex offsets — a flag rippling, a
+ * cape settling, a mouth shape morphing between drawn keys.
+ *
+ * It names BOTH the slot and the attachment, because a deform timeline is authored per (slot, attachment)
+ * pair: the same slot showing a different attachment is a different timeline. The binder stamps
+ * `attachment` into the slot's `Skeleton2DSlotDeform` so the pull seam can tell whether the offsets it
+ * finds belong to the art currently shown.
+ *
+ * The track is an ordinary numeric `AnimationTrack` whose `components` is the whole offset stream length,
+ * so nothing in `@flighthq/animation` widens to carry this — and unlike an attachment-swap index, deform
+ * offsets DO interpolate, which is what makes a morph move rather than snap.
+ */
+export interface Skeleton2DDeformAnimationTarget {
+    /** The attachment these offsets belong to; stamped onto the slot's deform record when bound. */
+    attachment: Attachment2D | null;
+    kind: Skeleton2DAnimationTargetKind;
+    slotIndex: number;
+}
+//# sourceMappingURL=Skeleton2DDeformAnimationTarget.d.ts.map

package/dist/Skeleton2DDeformAnimationTarget.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"Skeleton2DDeformAnimationTarget.d.ts","sourceRoot":"","sources":["../src/Skeleton2DDeformAnimationTarget.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,YAAY,EAAE,MAAM,mBAAmB,CAAC;AACtD,OAAO,KAAK,EAAE,6BAA6B,EAAE,MAAM,oCAAoC,CAAC;AAExF;;;;;;;;;;;;GAYG;AACH,MAAM,WAAW,+BAA+B;IAC9C,gGAAgG;IAChG,UAAU,EAAE,YAAY,GAAG,IAAI,CAAC;IAChC,IAAI,EAAE,6BAA6B,CAAC;IACpC,SAAS,EAAE,MAAM,CAAC;CACnB"}

package/dist/Skeleton2DDeformAnimationTarget.js

@@ -0,0 +1,2 @@
+export {};
+//# sourceMappingURL=Skeleton2DDeformAnimationTarget.js.map

package/dist/Skeleton2DDeformAnimationTarget.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"Skeleton2DDeformAnimationTarget.js","sourceRoot":"","sources":["../src/Skeleton2DDeformAnimationTarget.ts"],"names":[],"mappings":""}

package/dist/Skeleton2DDeformLengthExplanation.d.ts

@@ -0,0 +1,21 @@
+/**
+ * Why a deform offset stream was applied or ignored, as plain data — the shakeable `explain*` query paired
+ * with the silent sentinel in `skinSkeleton2DAttachmentPoints`. The guard says a mismatch happened; this
+ * says what the correct length would have been, which is the part a caller needs to fix it.
+ *
+ * `addressed` is the float count the attachment's own storage implies. The number that surprises people is
+ * the weighted one: offsets are addressed per INFLUENCE, not per vertex, so a mesh whose vertices average
+ * three bones needs three times the stream a per-vertex reading predicts. `addressing` names which rule
+ * produced it, because reading the wrong one is the mistake this exists to catch.
+ */
+export interface Skeleton2DDeformLengthExplanation {
+    /** True when the stream is long enough and the deform is applied. */
+    accepted: boolean;
+    /** `'weighted'` (per influence) or `'rigid'` (per vertex). */
+    addressing: string;
+    /** How many floats the attachment's storage addresses. */
+    addressed: number;
+    /** How many the offset stream carries. 0 for no stream at all. */
+    offsets: number;
+}
+//# sourceMappingURL=Skeleton2DDeformLengthExplanation.d.ts.map

package/dist/Skeleton2DDeformLengthExplanation.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"Skeleton2DDeformLengthExplanation.d.ts","sourceRoot":"","sources":["../src/Skeleton2DDeformLengthExplanation.ts"],"names":[],"mappings":"AAAA;;;;;;;;;GASG;AACH,MAAM,WAAW,iCAAiC;IAChD,qEAAqE;IACrE,QAAQ,EAAE,OAAO,CAAC;IAClB,8DAA8D;IAC9D,UAAU,EAAE,MAAM,CAAC;IACnB,0DAA0D;IAC1D,SAAS,EAAE,MAAM,CAAC;IAClB,kEAAkE;IAClE,OAAO,EAAE,MAAM,CAAC;CACjB"}

package/dist/Skeleton2DDeformLengthExplanation.js

@@ -0,0 +1,2 @@
+export {};
+//# sourceMappingURL=Skeleton2DDeformLengthExplanation.js.map

package/dist/Skeleton2DDeformLengthExplanation.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"Skeleton2DDeformLengthExplanation.js","sourceRoot":"","sources":["../src/Skeleton2DDeformLengthExplanation.ts"],"names":[],"mappings":""}

package/dist/Skeleton2DDrawOrderAnimationTarget.d.ts

@@ -0,0 +1,28 @@
+import type { Entity } from '@flighthq/entity/contract';
+import type { Node, NodeFields, NodeOrderList } from '@flighthq/node/contract';
+import type { Skeleton2DAnimationTargetKind } from './Skeleton2DAnimationTargetKind.ts';
+/**
+ * The binding target an `AnimationChannel` carries when it reorders a rig's drawing rather than moving
+ * it — Spine's draw-order timeline, and the second consumer of the same structure Rive's
+ * `DrawRules`/`DrawTarget` already import through.
+ *
+ * **Ordering is caller-owned and never node state**, per [draw order model](draw-order-model.md), so the
+ * target carries the `NodeOrderList` it writes into rather than the binder reaching for one. The binder
+ * fills the list; applying it to the parent stays the caller's explicit step, exactly as posing bones
+ * leaves the world-transform pass to the caller.
+ *
+ * `nodes` maps a slot index to the display node that slot draws, or `null` where it draws nothing —
+ * a lookup table for the same reason `Skeleton2DSlotAnimationTarget` carries its attachments, since a
+ * `Slot2D` knows what it wears and not where it lands in someone else's scene.
+ *
+ * The channel's track holds one **full ordering per keyframe**: `components` is the slot count, and the
+ * value at each slot's offset is that slot's sort key on that frame. A draw order is walked as steps
+ * whatever the track states — interpolating two orderings yields fractional sort keys and a sequence
+ * nobody authored — and that coercion reports through `enableSkeleton2DGuards`.
+ */
+export interface Skeleton2DDrawOrderAnimationTarget<Fields extends object = NodeFields> extends Entity {
+    kind: Skeleton2DAnimationTargetKind;
+    nodes: readonly (Node<Fields> | null)[];
+    orderList: NodeOrderList<Fields>;
+}
+//# sourceMappingURL=Skeleton2DDrawOrderAnimationTarget.d.ts.map

package/dist/Skeleton2DDrawOrderAnimationTarget.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"Skeleton2DDrawOrderAnimationTarget.d.ts","sourceRoot":"","sources":["../src/Skeleton2DDrawOrderAnimationTarget.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,MAAM,EAAE,MAAM,2BAA2B,CAAC;AACxD,OAAO,KAAK,EAAE,IAAI,EAAE,UAAU,EAAE,aAAa,EAAE,MAAM,yBAAyB,CAAC;AAE/E,OAAO,KAAK,EAAE,6BAA6B,EAAE,MAAM,oCAAoC,CAAC;AAExF;;;;;;;;;;;;;;;;;;GAkBG;AACH,MAAM,WAAW,kCAAkC,CAAC,MAAM,SAAS,MAAM,GAAG,UAAU,CAAE,SAAQ,MAAM;IACpG,IAAI,EAAE,6BAA6B,CAAC;IACpC,KAAK,EAAE,SAAS,CAAC,IAAI,CAAC,MAAM,CAAC,GAAG,IAAI,CAAC,EAAE,CAAC;IACxC,SAAS,EAAE,aAAa,CAAC,MAAM,CAAC,CAAC;CAClC"}

package/dist/Skeleton2DDrawOrderAnimationTarget.js

@@ -0,0 +1,2 @@
+export {};
+//# sourceMappingURL=Skeleton2DDrawOrderAnimationTarget.js.map

package/dist/Skeleton2DDrawOrderAnimationTarget.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"Skeleton2DDrawOrderAnimationTarget.js","sourceRoot":"","sources":["../src/Skeleton2DDrawOrderAnimationTarget.ts"],"names":[],"mappings":""}

package/dist/Skeleton2DDrawOrderTimeline.d.ts

@@ -0,0 +1,24 @@
+/**
+ * A rig's draw-order timeline as the file states it, carried on the import rather than as a channel.
+ *
+ * **A target names what the file states.** A draw-order channel's target needs a `NodeOrderList` and a
+ * slot-index-to-display-node table, and neither is rig data — nodes do not exist until a caller builds
+ * a scene. So the parser reports the orderings here and a scene-side step turns them into channels once
+ * there are nodes to name, which is the same division `@flighthq/scene2d-formats` already uses for Rive:
+ * the codec reports `DrawRules` and the caller wires the `NodeOrderList`.
+ *
+ * `orderings` holds **one full ordering per keyframe**, flat, in keyframe order — `slotCount` sort keys
+ * per keyframe, where the value at a slot's offset is that slot's draw position on that frame. Spine
+ * states the wire form as (slot, offset) pairs applied in sequence to the previous order, which cannot
+ * answer "what is in effect at time t" from one keyframe alone; resolving those pairs into whole
+ * orderings is the parser's job, so a consumer reads a self-contained frame.
+ *
+ * `slotCount` is `orderings.length / times.length` and is not stored separately, so the two cannot
+ * disagree.
+ */
+export interface Skeleton2DDrawOrderTimeline {
+    orderings: number[];
+    /** Seconds, one per keyframe, ascending. */
+    times: number[];
+}
+//# sourceMappingURL=Skeleton2DDrawOrderTimeline.d.ts.map

package/dist/Skeleton2DDrawOrderTimeline.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"Skeleton2DDrawOrderTimeline.d.ts","sourceRoot":"","sources":["../src/Skeleton2DDrawOrderTimeline.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;;;GAiBG;AACH,MAAM,WAAW,2BAA2B;IAC1C,SAAS,EAAE,MAAM,EAAE,CAAC;IACpB,4CAA4C;IAC5C,KAAK,EAAE,MAAM,EAAE,CAAC;CACjB"}

package/dist/Skeleton2DDrawOrderTimeline.js

@@ -0,0 +1,2 @@
+export {};
+//# sourceMappingURL=Skeleton2DDrawOrderTimeline.js.map

package/dist/Skeleton2DDrawOrderTimeline.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"Skeleton2DDrawOrderTimeline.js","sourceRoot":"","sources":["../src/Skeleton2DDrawOrderTimeline.ts"],"names":[],"mappings":""}

package/dist/Skeleton2DGuardsContract.d.ts

@@ -0,0 +1,38 @@
+/**
+ * What a channel's stated interpolation was replaced with, and why it had to be.
+ *
+ * Some channels carry a value that cannot be blended: an attachment index blended between two table
+ * entries names art that was never authored, and a draw order blended between two orderings produces
+ * fractional sort keys and a sequence nobody wrote. Those channels are walked as steps whatever their
+ * track claims, which is correct — but a coercion nobody can see is indistinguishable from the file
+ * having been authored that way, so the override is reported rather than performed in silence.
+ */
+export interface Skeleton2DCoercedInterpolation {
+    /** What the channel is actually walked as. Always `Step` today; stated so a reader need not assume. */
+    applied: string;
+    /** What the track claimed, which is what the author most likely set. */
+    stated: string;
+    /** Which channel family coerced — `Attachment` or `DrawOrder`. */
+    subject: string;
+}
+/**
+ * A deform offset stream that does not match the vertex stream it addresses.
+ *
+ * The offsets are ignored rather than partially applied: a stream of the wrong length has no correct
+ * prefix, so consuming what fits would deform some vertices and silently leave others behind. Reading
+ * past the buffer is never an option, and this is a sentinel rather than a throw because a malformed
+ * attachment is an asset fact.
+ */
+export interface Skeleton2DDeformLengthMismatch {
+    /** How many values the addressed vertex stream needs. */
+    addressed: number;
+    /** How many the offset stream actually carries. */
+    offsets: number;
+    /** Which attachment or slot the mismatch was found on, for a caller that has to go and fix it. */
+    subject: string;
+}
+/** Installed by `enableSkeleton2DGuards`; called when a channel's interpolation is overridden. */
+export type Skeleton2DCoercedInterpolationGuard = (report: Readonly<Skeleton2DCoercedInterpolation>) => void;
+/** Installed by `enableSkeleton2DGuards`; called when a deform offset stream is the wrong length. */
+export type Skeleton2DDeformLengthGuard = (report: Readonly<Skeleton2DDeformLengthMismatch>) => void;
+//# sourceMappingURL=Skeleton2DGuardsContract.d.ts.map

package/dist/Skeleton2DGuardsContract.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"Skeleton2DGuardsContract.d.ts","sourceRoot":"","sources":["../src/Skeleton2DGuardsContract.ts"],"names":[],"mappings":"AAAA;;;;;;;;GAQG;AACH,MAAM,WAAW,8BAA8B;IAC7C,uGAAuG;IACvG,OAAO,EAAE,MAAM,CAAC;IAChB,wEAAwE;IACxE,MAAM,EAAE,MAAM,CAAC;IACf,kEAAkE;IAClE,OAAO,EAAE,MAAM,CAAC;CACjB;AAED;;;;;;;GAOG;AACH,MAAM,WAAW,8BAA8B;IAC7C,yDAAyD;IACzD,SAAS,EAAE,MAAM,CAAC;IAClB,mDAAmD;IACnD,OAAO,EAAE,MAAM,CAAC;IAChB,kGAAkG;IAClG,OAAO,EAAE,MAAM,CAAC;CACjB;AAED,kGAAkG;AAClG,MAAM,MAAM,mCAAmC,GAAG,CAAC,MAAM,EAAE,QAAQ,CAAC,8BAA8B,CAAC,KAAK,IAAI,CAAC;AAE7G,qGAAqG;AACrG,MAAM,MAAM,2BAA2B,GAAG,CAAC,MAAM,EAAE,QAAQ,CAAC,8BAA8B,CAAC,KAAK,IAAI,CAAC"}

package/dist/Skeleton2DGuardsContract.js

@@ -0,0 +1,2 @@
+export {};
+//# sourceMappingURL=Skeleton2DGuardsContract.js.map

package/dist/Skeleton2DGuardsContract.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"Skeleton2DGuardsContract.js","sourceRoot":"","sources":["../src/Skeleton2DGuardsContract.ts"],"names":[],"mappings":""}

package/dist/Skeleton2DIkConstraint.d.ts

@@ -0,0 +1,29 @@
+import type { Skeleton2DConstraint } from './Skeleton2DConstraintContract.ts';
+/**
+ * Inverse kinematics over a one- or two-bone chain: rotate the chain so its tip reaches a target bone's
+ * world position, instead of animating each joint angle by hand.
+ *
+ * `boneIndices` is the chain in parent-to-child order — one bone (aim) or two (elbow/knee). Longer chains
+ * are a named deferral, not an oversight: both formats this models author one and two, and an N-bone
+ * solver is a different algorithm (iterative) rather than more of this one.
+ *
+ * `bendPositive` picks which of the two solutions a two-bone chain uses — the elbow that bends up or the
+ * one that bends down. It has no effect on a one-bone chain, which has a single solution.
+ *
+ * `stretch` lets a chain that cannot reach lengthen along its own axis instead of falling short, and
+ * `compress` lets a one-bone chain shorten when the target is nearer than its length. Both are scaled by
+ * `mix`, so a faded constraint stretches proportionally rather than snapping.
+ *
+ * Spine's `softness` (easing the last stretch of reach so a limb does not snap straight) is deliberately
+ * NOT a field here: carrying a field the solver does not honor is worse than not carrying it, so it is
+ * named as deferred rather than accepted and silently dropped.
+ */
+export interface Skeleton2DIkConstraint extends Skeleton2DConstraint {
+    bendPositive: boolean;
+    boneIndices: readonly number[];
+    compress: boolean;
+    kind: 'Skeleton2D.IkConstraint';
+    stretch: boolean;
+    targetBoneIndex: number;
+}
+//# sourceMappingURL=Skeleton2DIkConstraint.d.ts.map

package/dist/Skeleton2DIkConstraint.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"Skeleton2DIkConstraint.d.ts","sourceRoot":"","sources":["../src/Skeleton2DIkConstraint.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,oBAAoB,EAAE,MAAM,mCAAmC,CAAC;AAE9E;;;;;;;;;;;;;;;;;;GAkBG;AACH,MAAM,WAAW,sBAAuB,SAAQ,oBAAoB;IAClE,YAAY,EAAE,OAAO,CAAC;IACtB,WAAW,EAAE,SAAS,MAAM,EAAE,CAAC;IAC/B,QAAQ,EAAE,OAAO,CAAC;IAClB,IAAI,EAAE,yBAAyB,CAAC;IAChC,OAAO,EAAE,OAAO,CAAC;IACjB,eAAe,EAAE,MAAM,CAAC;CACzB"}

package/dist/Skeleton2DIkConstraint.js

@@ -0,0 +1,2 @@
+export {};
+//# sourceMappingURL=Skeleton2DIkConstraint.js.map

package/dist/Skeleton2DIkConstraint.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"Skeleton2DIkConstraint.js","sourceRoot":"","sources":["../src/Skeleton2DIkConstraint.ts"],"names":[],"mappings":""}

package/dist/Skeleton2DPathConstraint.d.ts

@@ -0,0 +1,53 @@
+import type { Skeleton2DConstraint } from './Skeleton2DConstraintContract.ts';
+/**
+ * Positions a chain of bones ALONG a vector path — a caterpillar track, a rope, a row of carriages
+ * following rails. The path is the attachment on a target slot, so the same `PathAttachment2D` that can
+ * be skinned by bones can also drive them.
+ *
+ * `position` is where along the path the first bone sits and `spacing` is the gap between successive
+ * bones; each is read in the units its mode names, which is why the modes exist rather than a single
+ * "distance" convention that would be wrong for half the rigs that use it.
+ *
+ * `rotateMode` decides what a bone's rotation follows: `Tangent` aims every bone along the path's own
+ * direction at its position, which is what a rope does; `Chain` aims each bone at the NEXT bone's
+ * position, which is what a linkage does and which keeps the chain rigid where the path is coarse.
+ *
+ * The three mixes are separate for the same reason the transform constraint's are: following a path's
+ * position while keeping authored rotation is a real authoring choice, not a degenerate case.
+ */
+export interface Skeleton2DPathConstraint extends Skeleton2DConstraint {
+    boneIndices: readonly number[];
+    kind: 'Skeleton2D.PathConstraint';
+    mixRotate: number;
+    mixX: number;
+    mixY: number;
+    /** Arc-length units when `Fixed`, a 0..1 fraction of the whole path when `Percent`. */
+    position: number;
+    positionMode: Skeleton2DPathPositionMode;
+    rotateMode: Skeleton2DPathRotateMode;
+    /**
+     * Arc-length units when `Fixed`, a 0..1 fraction of the path when `Percent`, and a multiple of each
+     * bone's own `length` when `Length` — the mode that keeps a chain of unequal bones evenly jointed.
+     */
+    spacing: number;
+    spacingMode: Skeleton2DPathSpacingMode;
+    /** The slot whose attachment is the `PathAttachment2D` to follow. */
+    targetSlotIndex: number;
+}
+export declare const Skeleton2DPathPositionMode: {
+    readonly Fixed: 'Fixed';
+    readonly Percent: 'Percent';
+};
+export type Skeleton2DPathPositionMode = (typeof Skeleton2DPathPositionMode)[keyof typeof Skeleton2DPathPositionMode];
+export declare const Skeleton2DPathRotateMode: {
+    readonly Chain: 'Chain';
+    readonly Tangent: 'Tangent';
+};
+export type Skeleton2DPathRotateMode = (typeof Skeleton2DPathRotateMode)[keyof typeof Skeleton2DPathRotateMode];
+export declare const Skeleton2DPathSpacingMode: {
+    readonly Fixed: 'Fixed';
+    readonly Length: 'Length';
+    readonly Percent: 'Percent';
+};
+export type Skeleton2DPathSpacingMode = (typeof Skeleton2DPathSpacingMode)[keyof typeof Skeleton2DPathSpacingMode];
+//# sourceMappingURL=Skeleton2DPathConstraint.d.ts.map

package/dist/Skeleton2DPathConstraint.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"Skeleton2DPathConstraint.d.ts","sourceRoot":"","sources":["../src/Skeleton2DPathConstraint.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,oBAAoB,EAAE,MAAM,mCAAmC,CAAC;AAE9E;;;;;;;;;;;;;;;GAeG;AACH,MAAM,WAAW,wBAAyB,SAAQ,oBAAoB;IACpE,WAAW,EAAE,SAAS,MAAM,EAAE,CAAC;IAC/B,IAAI,EAAE,2BAA2B,CAAC;IAClC,SAAS,EAAE,MAAM,CAAC;IAClB,IAAI,EAAE,MAAM,CAAC;IACb,IAAI,EAAE,MAAM,CAAC;IACb,uFAAuF;IACvF,QAAQ,EAAE,MAAM,CAAC;IACjB,YAAY,EAAE,0BAA0B,CAAC;IACzC,UAAU,EAAE,wBAAwB,CAAC;IACrC;;;OAGG;IACH,OAAO,EAAE,MAAM,CAAC;IAChB,WAAW,EAAE,yBAAyB,CAAC;IACvC,qEAAqE;IACrE,eAAe,EAAE,MAAM,CAAC;CACzB;AAED,eAAO,MAAM,0BAA0B;aACrC,KAAK,EAAE,OAAO;aACd,OAAO,EAAE,SAAS;CACV,CAAC;AAEX,MAAM,MAAM,0BAA0B,GAAG,CAAC,OAAO,0BAA0B,CAAC,CAAC,MAAM,OAAO,0BAA0B,CAAC,CAAC;AAEtH,eAAO,MAAM,wBAAwB;aACnC,KAAK,EAAE,OAAO;aACd,OAAO,EAAE,SAAS;CACV,CAAC;AAEX,MAAM,MAAM,wBAAwB,GAAG,CAAC,OAAO,wBAAwB,CAAC,CAAC,MAAM,OAAO,wBAAwB,CAAC,CAAC;AAEhH,eAAO,MAAM,yBAAyB;aACpC,KAAK,EAAE,OAAO;aACd,MAAM,EAAE,QAAQ;aAChB,OAAO,EAAE,SAAS;CACV,CAAC;AAEX,MAAM,MAAM,yBAAyB,GAAG,CAAC,OAAO,yBAAyB,CAAC,CAAC,MAAM,OAAO,yBAAyB,CAAC,CAAC"}

package/dist/Skeleton2DPathConstraint.js

@@ -0,0 +1,14 @@
+export const Skeleton2DPathPositionMode = {
+    Fixed: 'Fixed',
+    Percent: 'Percent',
+};
+export const Skeleton2DPathRotateMode = {
+    Chain: 'Chain',
+    Tangent: 'Tangent',
+};
+export const Skeleton2DPathSpacingMode = {
+    Fixed: 'Fixed',
+    Length: 'Length',
+    Percent: 'Percent',
+};
+//# sourceMappingURL=Skeleton2DPathConstraint.js.map

package/dist/Skeleton2DPathConstraint.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"Skeleton2DPathConstraint.js","sourceRoot":"","sources":["../src/Skeleton2DPathConstraint.ts"],"names":[],"mappings":"AAsCA,MAAM,CAAC,MAAM,0BAA0B,GAAG;IACxC,KAAK,EAAE,OAAO;IACd,OAAO,EAAE,SAAS;CACV,CAAC;AAIX,MAAM,CAAC,MAAM,wBAAwB,GAAG;IACtC,KAAK,EAAE,OAAO;IACd,OAAO,EAAE,SAAS;CACV,CAAC;AAIX,MAAM,CAAC,MAAM,yBAAyB,GAAG;IACvC,KAAK,EAAE,OAAO;IACd,MAAM,EAAE,QAAQ;IAChB,OAAO,EAAE,SAAS;CACV,CAAC"}

package/dist/Skeleton2DSlotAnimationTarget.d.ts

@@ -0,0 +1,15 @@
+import type { Entity } from '@flighthq/entity/contract';
+import type { Attachment2D } from './Attachment2D.ts';
+import type { Skeleton2DAnimationTargetKind } from './Skeleton2DAnimationTargetKind.ts';
+export declare const Skeleton2DSlotAnimationPath: {
+    readonly Attachment: 'Attachment';
+    readonly Color: 'Color';
+};
+export type Skeleton2DSlotAnimationPath = (typeof Skeleton2DSlotAnimationPath)[keyof typeof Skeleton2DSlotAnimationPath];
+export interface Skeleton2DSlotAnimationTarget extends Entity {
+    attachments?: readonly (Attachment2D | null)[] | null;
+    kind: Skeleton2DAnimationTargetKind;
+    path: Skeleton2DSlotAnimationPath;
+    slotIndex: number;
+}
+//# sourceMappingURL=Skeleton2DSlotAnimationTarget.d.ts.map

package/dist/Skeleton2DSlotAnimationTarget.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"Skeleton2DSlotAnimationTarget.d.ts","sourceRoot":"","sources":["../src/Skeleton2DSlotAnimationTarget.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,MAAM,EAAE,MAAM,2BAA2B,CAAC;AAExD,OAAO,KAAK,EAAE,YAAY,EAAE,MAAM,mBAAmB,CAAC;AACtD,OAAO,KAAK,EAAE,6BAA6B,EAAE,MAAM,oCAAoC,CAAC;AAexF,eAAO,MAAM,2BAA2B;aACtC,UAAU,EAAE,YAAY;aACxB,KAAK,EAAE,OAAO;CACN,CAAC;AAEX,MAAM,MAAM,2BAA2B,GACrC,CAAC,OAAO,2BAA2B,CAAC,CAAC,MAAM,OAAO,2BAA2B,CAAC,CAAC;AAyBjF,MAAM,WAAW,6BAA8B,SAAQ,MAAM;IAC3D,WAAW,CAAC,EAAE,SAAS,CAAC,YAAY,GAAG,IAAI,CAAC,EAAE,GAAG,IAAI,CAAC;IACtD,IAAI,EAAE,6BAA6B,CAAC;IACpC,IAAI,EAAE,2BAA2B,CAAC;IAClC,SAAS,EAAE,MAAM,CAAC;CACnB"}

package/dist/Skeleton2DSlotAnimationTarget.js

@@ -0,0 +1,18 @@
+// Which part of a `Slot2D`'s appearance an AnimationChannel drives — the slot-side counterpart of
+// `Skeleton2DAnimationPath`, which covers only bone transforms.
+//
+//   Color      — drives the packed `Slot2D.color`  [Vector4 track, components 4, channels 0..1 R,G,B,A]
+//   Attachment — drives which attachment the slot shows [scalar STEP track of indices into `attachments`]
+//
+// Colour channels are NORMALIZED 0..1, not 0..255, even though `Slot2D.color` packs bytes. That is the space
+// Spine authors its colour CURVE control points in, so a 0..255 track would rebase every colour easing
+// against the wrong scale; the binder converts to bytes when it packs.
+//
+// Deliberately small. Spine's second ("dark") slot colour has no `Slot2D` representation at all, and
+// draw-order timelines mutate the draw list rather than a value on a slot, so neither is modeled here; both
+// are named deferrals rather than oversights (see agents/skeleton2d-animation-model.md).
+export const Skeleton2DSlotAnimationPath = {
+    Attachment: 'Attachment',
+    Color: 'Color',
+};
+//# sourceMappingURL=Skeleton2DSlotAnimationTarget.js.map

package/dist/Skeleton2DSlotAnimationTarget.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"Skeleton2DSlotAnimationTarget.js","sourceRoot":"","sources":["../src/Skeleton2DSlotAnimationTarget.ts"],"names":[],"mappings":"AAKA,kGAAkG;AAClG,gEAAgE;AAChE,EAAE;AACF,wGAAwG;AACxG,0GAA0G;AAC1G,EAAE;AACF,6GAA6G;AAC7G,uGAAuG;AACvG,uEAAuE;AACvE,EAAE;AACF,qGAAqG;AACrG,4GAA4G;AAC5G,yFAAyF;AACzF,MAAM,CAAC,MAAM,2BAA2B,GAAG;IACzC,UAAU,EAAE,YAAY;IACxB,KAAK,EAAE,OAAO;CACN,CAAC"}

package/dist/Skeleton2DSlotDeform.d.ts

@@ -0,0 +1,29 @@
+import type { Attachment2D } from './Attachment2D.ts';
+/**
+ * The per-vertex offset stream in effect on a slot, together with THE ATTACHMENT IT WAS AUTHORED FOR.
+ *
+ * A deform belongs to a (slot, attachment) PAIR, not to a slot: the attachment is shared art, so two
+ * slots showing the same mesh deform independently, and one slot that SWAPS attachments must not carry
+ * the old one's offsets onto the new art. Pairing the offsets with their attachment here is what makes
+ * that impossible to express, rather than something a consumer has to remember to check.
+ *
+ * This is the invalidation doctrine's compare-identities rule applied literally: `attachment` is a
+ * reference-shaped field re-read at the pull seam (`getSkeleton2DSlotDeformOffsets`), and bare assignment
+ * is the API — nothing has to be invalidated when a swap happens, because the comparison catches it.
+ *
+ * A bare `Float32Array` on the slot was the alternative and it is unsafe in a way a length check cannot
+ * fix. Of the three ways a swap can change size, only ONE is detectable by length: swapping to a LARGER
+ * attachment leaves the buffer too short and is caught, while swapping to an EQUAL or SMALLER one passes
+ * a `>=` check and silently deforms the new art with the old offsets. Equal is also the common case, since
+ * matching point counts are what make a swap look continuous.
+ */
+export interface Skeleton2DSlotDeform {
+    /** The attachment these offsets were authored against. Compared, never followed. */
+    attachment: Attachment2D | null;
+    /**
+     * The offset stream, addressed as the attachment stores its positions — two floats per INFLUENCE for a
+     * weighted attachment, two per VERTEX for a rigid one. See `explainSkeleton2DDeformLength`.
+     */
+    offsets: Float32Array;
+}
+//# sourceMappingURL=Skeleton2DSlotDeform.d.ts.map

package/dist/Skeleton2DSlotDeform.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"Skeleton2DSlotDeform.d.ts","sourceRoot":"","sources":["../src/Skeleton2DSlotDeform.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,YAAY,EAAE,MAAM,mBAAmB,CAAC;AAEtD;;;;;;;;;;;;;;;;;GAiBG;AACH,MAAM,WAAW,oBAAoB;IACnC,oFAAoF;IACpF,UAAU,EAAE,YAAY,GAAG,IAAI,CAAC;IAChC;;;OAGG;IACH,OAAO,EAAE,YAAY,CAAC;CACvB"}

package/dist/Skeleton2DSlotDeform.js

@@ -0,0 +1,2 @@
+export {};
+//# sourceMappingURL=Skeleton2DSlotDeform.js.map

package/dist/Skeleton2DSlotDeform.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"Skeleton2DSlotDeform.js","sourceRoot":"","sources":["../src/Skeleton2DSlotDeform.ts"],"names":[],"mappings":""}