@tawaship/pixi-animate-runtime 0.0.0-stage → 0.1.0

package/types/player/geom.d.ts

@@ -0,0 +1,19 @@
+import * as PIXI from 'pixi.js';
+/**
+ * createjs-compatible Rectangle (its own members are exactly x, y, width,
+ * height, as createjs's; Pixi's Rectangle also carries a shape type).
+ */
+export declare class Rectangle {
+    x: number;
+    y: number;
+    width: number;
+    height: number;
+    constructor(x?: number, y?: number, width?: number, height?: number);
+    setValues(x?: number, y?: number, width?: number, height?: number): this;
+    copy(rect: Rectangle): this;
+    clone(): Rectangle;
+    contains(x: number, y: number, width?: number, height?: number): boolean;
+    isEmpty(): boolean;
+    toPixi(): PIXI.Rectangle;
+    toString(): string;
+}

package/types/player/index.d.ts

@@ -0,0 +1,20 @@
+export { Event, EventDispatcher } from './events';
+export type { TEventListener, IEventHandlerObject } from './events';
+export { DisplayObject, Container, PixiContainer } from './display';
+export type { IOwnedNode, IFilterLike, ICacheState } from './display';
+export { CjsTransform } from './transform';
+export { Rectangle } from './geom';
+export { MovieClip, Timeline, TweenState, INDEPENDENT, SINGLE_FRAME, SYNCHED } from './movieclip';
+export type { TScript, TWriter, TMemberWriter, TWrittenValue, ITweenScope, IFilterCacheEntry } from './movieclip';
+export { Shape, Graphics, Sprite, SpriteSheet, Bitmap, Text, ColorFilter, ButtonHelper, GraphicsCommand, GRAPHICS_COMMANDS, PixiGraphics, PixiSprite, PixiText, drawCommands, parseColor, GradientTexture } from './objects';
+export type { ITextureSource, IImageAsset, ISpriteFrame, IButtonTarget, IGradient } from './objects';
+export { Content, tick, resolveState, namespace } from './content';
+export { AnimateContainer, AnimateController } from './animate-container';
+export { loadContentAsync, getContentFactory, resolveContentUrl, CONTENTS_GLOBAL } from './loader';
+export type { IContentTarget, ILoadContentOptions, IContentManifestEntry } from './loader';
+export type { TContentFactory, IGeneratedContent, IContentAssets, IContent, IContentProperties, TContentProperty, ILibrary, TSymbolClass, TMovieClipClass, TSpriteClass, TBitmapClass, TNamespace, ISilentSound } from './content';
+export { RUNTIME_CONTENT_RANGE } from './data';
+export { VERSION } from './version';
+export { parseVersion, compareVersions, satisfies, checkVersion } from './semver';
+export type { IVersionCheck } from './semver';
+export type { IRuntimeData, TRuntimeSymbolDef, IRuntimeMovieClipDef, IRuntimeTweenDef, IRuntimeActionDef, IRuntimeSlotDef, TRuntimeSlotData, TRuntimeSlotRef, IRuntimeTweenData, IRuntimeGraphicsData, TRuntimeCommand, TRuntimeCommandKind, TRuntimeFrameValue } from './data';

package/types/player/loader.d.ts

@@ -0,0 +1,53 @@
+import { IContent, TContentFactory } from './content';
+/**
+ * The global runtime content files register their factories in, by
+ * composition id: `window.PixiAnimateRuntimeContents[id] = factory`. It is not
+ * under the player's namespace, so that a runtime content file can be loaded
+ * before the player, and the same file serves every player package.
+ */
+export declare const CONTENTS_GLOBAL = "PixiAnimateRuntimeContents";
+/** What to load a content from: its composition id, and the directory its images are relative to */
+export interface IContentTarget {
+    /** The content's composition id (lib.properties.id of the published content) */
+    id: string;
+    /** The directory the content's image paths are relative to (usually where its runtime content file is) */
+    basepath: string;
+    options?: {
+        /** Whether images are requested with CORS (anonymous). true when omitted */
+        crossOrigin?: boolean;
+        /**
+         * Called with the content's images before they are loaded (a copy for this
+         * load): changing an entry's src changes what is loaded, such as a data: or
+         * blob: URL in place of the file
+         */
+        handleManifest?: (manifest: IContentManifestEntry[]) => Promise<void> | void;
+    };
+}
+/** An image of a content: its manifest id and its path (relative to the base path, as published) */
+export interface IContentManifestEntry {
+    id: string;
+    src: string;
+}
+export interface ILoadContentOptions {
+    /** Added to every image URL as the query `_fv=<version>` (the query an image path already has stays) */
+    version?: string | number;
+}
+/**
+ * The factory a runtime content file registered under a composition id. The
+ * file has to be loaded first (a script tag, or any other way).
+ */
+export declare function getContentFactory(id: string): TContentFactory;
+/**
+ * The URL of a content's image: its path resolved against the base path, with
+ * the version added as `_fv=<version>` (the query the path already has, such as
+ * the one Animate adds on every publish, stays). data: and blob: URLs are used
+ * as they are. The same as Pixim.js's utils.resolveUri.
+ */
+export declare function resolveContentUrl(basepath: string, src: string, version?: string | number | null): string;
+/**
+ * Loads contents: the factory each runtime content file registered under the
+ * target's composition id (the file has to be loaded already), the content's
+ * images from the target's base path, and the content built with them.
+ */
+export declare function loadContentAsync(target: IContentTarget, options?: ILoadContentOptions): Promise<IContent>;
+export declare function loadContentAsync(targets: IContentTarget[], options?: ILoadContentOptions): Promise<IContent[]>;

package/types/player/movieclip.d.ts

@@ -0,0 +1,191 @@
+import { Container, DisplayObject, IOwnedNode } from './display';
+import { Event } from './events';
+import type { IRuntimeTweenDef, IStateEntryDef, TFrameValue, ILabelDef } from './data';
+/** A frame script, called with the clip as `this` */
+export type TScript = (...args: Array<object | string | number | boolean | null>) => void;
+/** A recorded value as written (Graphics references resolved) */
+export type TWrittenValue = object | string | number | boolean | null;
+/**
+ * A generated writer: writes the recorded values to the target property by
+ * property, the names written out in its code (values[i] to the i-th
+ * property; resolve turns a recorded Graphics reference into the Graphics).
+ * An initial-value writer has its values in its code and takes the target only.
+ */
+export type TWriter = (target: object, values?: TFrameValue[], resolve?: (value: TFrameValue) => TWrittenValue) => void;
+/** Gives an instance its named children: `self.<name> = slots[<slot>]` for each, the names written in the code */
+export type TMemberWriter = (self: object, slots: object[]) => void;
+/**
+ * What a MovieClip instance needs to play a tween of its symbol: how to find
+ * the objects a recorded value refers to.
+ */
+export interface ITweenScope {
+    /** The target of a state entry (a slot of the instance) */
+    stateTarget(entry: IStateEntryDef): DisplayObject | null;
+    /** A recorded value as written (Graphics references resolved) */
+    value(value: TFrameValue): TWrittenValue;
+    /** A frame script by index */
+    script(index: number): TScript;
+    /** A writer by index */
+    writer(index: number): TWriter;
+}
+/**
+ * The playback state of one tween of an instance. The values come from the
+ * shared definition; only the positions are per instance.
+ */
+export declare class TweenState {
+    readonly def: IRuntimeTweenDef;
+    /**
+     * What the tween writes to: a display object or a filter (through their
+     * accessors), or the plain object published code tweens `state` arrays on
+     */
+    readonly target: object;
+    readonly scope: ITweenScope;
+    readonly self: MovieClip;
+    position: number;
+    rawPosition: number;
+    /** Distance from the start of the current step (synched children take their frame from it) */
+    _stepPosition: number;
+    passive: boolean;
+    constructor(def: IRuntimeTweenDef, target: object, scope: ITweenScope, self: MovieClip);
+    get duration(): number;
+    /**
+     * Tween.setPosition as a timeline drives it (actions are run separately by
+     * the timeline). Nothing happens when the raw position does not change.
+     */
+    setPosition(rawPosition: number, jump: boolean): void;
+    private _updatePosition;
+    /** AbstractTween._runActions for this tween's actions */
+    _runActions(startRaw: number, endRaw: number, jump: boolean, includeStart: boolean): boolean;
+    /** Tween._runActionsRange: runs the actions in the range, stopping when one moves the tween */
+    _runActionsRange(start: number, end: number, jump: boolean, includeStart: boolean): boolean;
+}
+interface IActionRunner {
+    _runActionsRange(start: number, end: number, jump: boolean, includeStart: boolean): boolean;
+}
+/**
+ * The timeline of a MovieClip instance (createjs.Timeline as a MovieClip drives it).
+ */
+export declare class Timeline implements IActionRunner {
+    readonly tweens: TweenState[];
+    readonly duration: number;
+    loop: number;
+    position: number;
+    rawPosition: number;
+    private readonly _labels;
+    private readonly _labelList;
+    constructor(duration: number, labels: ILabelDef[]);
+    getLabels(): ILabelDef[];
+    get currentLabel(): string | null;
+    resolve(positionOrLabel: string | number): number | undefined;
+    /**
+     * AbstractTween.setPosition for the timeline: moves every tween, calls
+     * back (the clip resolves its children), then runs the actions passed.
+     */
+    setPosition(rawPosition: number, skipActions: boolean, jump: boolean, callback: (() => void) | null): void;
+    _runActionsRange(start: number, end: number, jump: boolean, includeStart: boolean): boolean;
+}
+export interface IFilterCacheEntry {
+    instance: DisplayObject;
+    startFrame: number;
+    endFrame: number;
+    x: number;
+    y: number;
+    w: number;
+    h: number;
+}
+export declare const INDEPENDENT = "independent";
+export declare const SINGLE_FRAME = "single";
+export declare const SYNCHED = "synched";
+/**
+ * createjs-compatible MovieClip. Plays its symbol's timeline from the shared
+ * definition with createjs's rules: the two phases (tick: advance the
+ * playhead; then resolve: write the tweens and settle the children), the
+ * write rule (a tween writes only when its position changes), synched /
+ * single children taking their frame from the parent's step, the reset of an
+ * independent child when it comes back on the display list, and when frame
+ * scripts run.
+ */
+export declare class MovieClip extends Container {
+    static INDEPENDENT: string;
+    static SINGLE_FRAME: string;
+    static SYNCHED: string;
+    mode: string;
+    startPosition: number;
+    loop: number;
+    currentFrame: number;
+    paused: boolean;
+    actionsEnabled: boolean;
+    autoReset: boolean;
+    framerate: number | null;
+    timeline: Timeline;
+    _synchOffset: number;
+    _rawPosition: number;
+    _t: number;
+    _framerate: number | null;
+    /**
+     * Display objects the timeline placed, with the resolve that last placed
+     * them (_resolveCount at that time). One placed in an earlier resolve and
+     * not in the current one is removed at its end (createjs marks every entry
+     * 1 at the start of a resolve and placed ones 2: an earlier count is its 1)
+     */
+    _managed: {
+        [id: number]: number;
+    };
+    private _resolveCount;
+    /**
+     * While a resolve can still leave the display list as it is: the index of
+     * the child the next placement has to be for that (createjs moves each placed
+     * child to the bottom, so in a resolve that changes nothing they come from
+     * the top of the placed block down), -1 once all have come. Null when the
+     * placements are done as createjs does them.
+     */
+    private _expected;
+    /** The length of the placed block at the start of the resolve (the children placed last time, at the bottom) */
+    private _placedBlock;
+    /**
+     * Instances to re-cache within frame ranges, read by the filter cache
+     * handling (published code sets it in the symbol's constructor)
+     */
+    filterCacheList?: IFilterCacheEntry[];
+    /** The frame rate the content was published with (lib.properties.fps), set on the content's symbols */
+    contentFps: number | null;
+    private readonly _boundResolve;
+    constructor(mode?: string | null, startPosition?: number | null, loop?: boolean | number | null, timeline?: Timeline, pixi?: IOwnedNode);
+    get labels(): ILabelDef[];
+    get currentLabel(): string | null;
+    get totalFrames(): number;
+    get duration(): number;
+    isVisible(): boolean;
+    play(): void;
+    stop(): void;
+    gotoAndPlay(positionOrLabel: string | number): void;
+    gotoAndStop(positionOrLabel: string | number): void;
+    advance(time?: number | null): void;
+    /** createjs tick phase: advance the playhead, then the children (reverse), then tick listeners */
+    _tick(event: Event): void;
+    /** createjs resolve phase (MovieClip draw / Stage update) */
+    _updateState(): void;
+    _goto(positionOrLabel: string | number): void;
+    _reset(): void;
+    _updateTimeline(rawPosition: number, jump: boolean): void;
+    _renderFirstFrame(): void;
+    /**
+     * MovieClip._resolveState: places every tween target (and state entry) at
+     * the bottom of the display list in turn, then removes the children placed
+     * before and not now. The placements are skipped while they would leave the
+     * display list as it is (_addManagedChild); otherwise everything is done as
+     * createjs does it.
+     */
+    _resolveState(): void;
+    /**
+     * Stops skipping placements: the children placed so far (the top of the
+     * block, from the expected index up) are moved to the bottom as createjs's
+     * placements would have left them, with no events (moves within the same
+     * parent are silent in createjs).
+     */
+    _followCreatejs(): void;
+    _setState(state: IStateEntryDef[] | object | string | number | boolean | null | undefined, scope: ITweenScope, offset: number): void;
+    _addManagedChild(child: DisplayObject, offset: number): void;
+    toString(): string;
+}
+export {};

package/types/player/objects.d.ts

@@ -0,0 +1,320 @@
+import * as PIXI from 'pixi.js';
+import { DisplayObject, Container, IOwnedNode } from './display';
+import { Event } from './events';
+import { Rectangle } from './geom';
+import type { IGraphicsCommandDef, TDataValue } from './data';
+export declare class PixiGraphics extends PIXI.Graphics implements IOwnedNode {
+    owner: DisplayObject | null;
+    /**
+     * Shows another (shared) geometry. Pixi 5 can share a geometry between
+     * Graphics (new Graphics(geometry), as clone() does) but has no way to
+     * change it afterwards, and does not declare the field that holds it; it is
+     * set by name here, and what Pixi derives from the geometry (the batches,
+     * their vertices and tint) is marked stale so it is built again.
+     */
+    setGeometry(geometry: PIXI.GraphicsGeometry): void;
+    /**
+     * Pixi 5's Graphics keeps the blend mode in the batches it builds, and
+     * builds them again only when the geometry changes: a blend mode set later
+     * would not be drawn. The batches are marked stale so they are built again.
+     */
+    setBlendMode(mode: PIXI.BLEND_MODES): void;
+}
+export declare class PixiSprite extends PIXI.Sprite implements IOwnedNode {
+    owner: DisplayObject | null;
+}
+export declare class PixiText extends PIXI.Text implements IOwnedNode {
+    owner: DisplayObject | null;
+}
+/**
+ * Where a content's images come from: manifest images by id, and frames of
+ * its sprite sheets (the images published code draws from a frame for a
+ * bitmap fill).
+ */
+export interface ITextureSource {
+    image(id: string): PIXI.Texture | null;
+    frame(sheet: string, index: number): PIXI.Texture | null;
+    imageAsset(id: string): IImageAsset | null;
+    frameAsset(sheet: string, index: number): IImageAsset | null;
+}
+interface IColor {
+    color: number;
+    alpha: number;
+}
+/**
+ * A CSS color as createjs writes it (#RGB, #RRGGBB, rgb(), rgba(), a few names).
+ */
+export declare function parseColor(value: TDataValue | undefined): IColor | null;
+/**
+ * A linear or radial gradient as createjs makes it (the props of a Fill or
+ * Stroke style made by beginLinearGradientFill and the like): colors at
+ * ratios along the line from (x0, y0) to (x1, y1), or between the circles
+ * (x0, y0, r0) and (x1, y1, r1), in the shape's coordinates.
+ */
+export interface IGradient {
+    type: 'linear' | 'radial';
+    colors: string[];
+    ratios: number[];
+    x0: number;
+    y0: number;
+    r0: number;
+    x1: number;
+    y1: number;
+    r1: number;
+}
+/**
+ * A gradient drawn into a canvas by the browser's own gradient (so its
+ * colors are what canvas, and createjs, paints), as a texture that Pixi's
+ * Graphics fills and strokes with through a matrix. `gradient` is the
+ * gradient in the shape's coordinates, `local` the same gradient in the
+ * texture's pixels, and `toShape` takes texture pixels to the shape's
+ * coordinates. Outside the drawn area the texture's edge pixels repeat
+ * (Pixi clamps), which is how canvas pads a gradient with its end colors.
+ */
+export declare class GradientTexture extends PIXI.Texture {
+    readonly gradient: IGradient;
+    readonly local: IGradient;
+    readonly toShape: PIXI.Matrix;
+    constructor(canvas: HTMLCanvasElement, gradient: IGradient, local: IGradient, toShape: PIXI.Matrix);
+}
+/**
+ * Draws createjs drawing commands into a Pixi Graphics. Pixi takes the paint
+ * first, so each path is replayed under the paint that follows it, with the
+ * holes canvas's nonzero fill would cut (holes: the MoveTo commands that
+ * start holes, see Graphics.holes).
+ */
+export declare function drawCommands(target: PIXI.Graphics, commands: IGraphicsCommandDef[], textures: ITextureSource, holes?: IGraphicsCommandDef[] | null): void;
+/**
+ * A drawing command as createjs keeps it (Graphics.MoveTo, Graphics.Fill, ...):
+ * the command's own properties, with fill and stroke styles as objects whose
+ * `props` are the arguments they were made with.
+ */
+export declare class GraphicsCommand {
+}
+/** The createjs drawing command class names */
+export declare const GRAPHICS_COMMANDS: string[];
+/**
+ * Draws the path of createjs drawing commands filled, ignoring their fills
+ * and strokes: the shape a createjs mask clips with (all the drawing as one
+ * path, with the holes named by holes, see Graphics.maskHoles).
+ */
+export declare function drawMaskPath(target: PIXI.Graphics, commands: IGraphicsCommandDef[], holes?: IGraphicsCommandDef[] | null): void;
+/**
+ * createjs-compatible Graphics holding the drawing commands of a definition.
+ */
+export declare class Graphics {
+    readonly commands: IGraphicsCommandDef[];
+    readonly textures: ITextureSource;
+    private _instructions;
+    private _holes;
+    private _maskHoles;
+    private _geometry;
+    private _maskGeometry;
+    constructor(commands: IGraphicsCommandDef[], textures: ITextureSource);
+    /** The commands as createjs's command objects (made when first read) */
+    get instructions(): GraphicsCommand[];
+    isEmpty(): boolean;
+    /**
+     * The MoveTo commands that start holes in the filled paths (worked out once
+     * per drawing and shared by every shape that shows it)
+     */
+    holes(): IGraphicsCommandDef[];
+    /**
+     * The drawing as a Pixi geometry, drawn the first time it is asked for and
+     * shared from then on by every shape that shows this drawing (a shape's
+     * Pixi node must therefore not be drawn into: that would change it for all)
+     */
+    geometry(): PIXI.GraphicsGeometry;
+    /** The drawing as a mask (its path filled), shared the same way */
+    maskGeometry(): PIXI.GraphicsGeometry;
+    /** The holes of the drawing as a mask (all of it one path) */
+    maskHoles(): IGraphicsCommandDef[];
+}
+/**
+ * createjs-compatible Shape on a Pixi Graphics.
+ */
+export declare class Shape extends DisplayObject {
+    readonly pixiGraphics: PixiGraphics;
+    private _graphics;
+    /** The shape as a mask (made when first used as one), a child of this shape's node */
+    private _maskGraphics;
+    constructor(graphics?: Graphics | null);
+    get graphics(): Graphics | null;
+    set graphics(value: Graphics | null);
+    _clipsAsMask(): boolean;
+    _setBlendMode(mode: PIXI.BLEND_MODES): void;
+    /**
+     * createjs clips with the shape's path alone (Graphics.drawAsPath, then
+     * clip), whatever its fill and stroke; published masks are paths with no
+     * fill. The mask node is that path, filled. It is a child of the shape's
+     * node, so it moves with the shape (the shape's own node is not drawn while
+     * it serves as a mask).
+     */
+    _pixiMaskNode(): PIXI.Container;
+    _releaseMaskNode(): void;
+    toString(): string;
+}
+/**
+ * A frame of a sprite sheet, as createjs describes it.
+ */
+export interface ISpriteFrame {
+    image: IImageAsset;
+    rect: Rectangle;
+}
+/**
+ * An image as content sees it (`src` names it).
+ */
+export interface IImageAsset {
+    src: string;
+    texture: PIXI.Texture;
+}
+/**
+ * createjs-compatible SpriteSheet: frames cut from an atlas image.
+ */
+export declare class SpriteSheet {
+    readonly frames: ISpriteFrame[];
+    readonly textures: PIXI.Texture[];
+    framerate: number;
+    complete: boolean;
+    constructor(image: IImageAsset, rects: number[][]);
+    getFrame(index: number): ISpriteFrame | null;
+    getNumFrames(): number;
+}
+/**
+ * createjs-compatible Sprite (frame by frame from a sprite sheet).
+ */
+export declare class Sprite extends DisplayObject {
+    readonly pixiSprite: PixiSprite;
+    spriteSheet: SpriteSheet;
+    currentFrame: number;
+    paused: boolean;
+    framerate: number;
+    constructor(spriteSheet: SpriteSheet, frame?: number);
+    play(): void;
+    stop(): void;
+    gotoAndPlay(frame: number): void;
+    gotoAndStop(frame: number): void;
+    advance(): void;
+    _goto(frame: number): void;
+    _tick(event: Event): void;
+    _setBlendMode(mode: PIXI.BLEND_MODES): void;
+    toString(): string;
+}
+/**
+ * createjs-compatible Bitmap.
+ */
+export declare class Bitmap extends DisplayObject {
+    readonly pixiSprite: PixiSprite;
+    private _image;
+    private _sourceRect;
+    constructor(image?: IImageAsset | null);
+    get image(): IImageAsset | null;
+    set image(value: IImageAsset | null);
+    get sourceRect(): Rectangle | null;
+    set sourceRect(value: Rectangle | null);
+    private _updateTexture;
+    _setBlendMode(mode: PIXI.BLEND_MODES): void;
+    toString(): string;
+}
+/**
+ * The lines createjs draws a text in (Text._drawText): the text split at line
+ * breaks (CR LF, CR, LF), then a line wider than lineWidth broken at whitespace
+ * only, words added while they fit (a word wider than lineWidth stays whole).
+ * No breaking at all when lineWidth is null.
+ */
+export declare function breakLines(text: string, lineWidth: number | null, measure: (line: string) => number): string[];
+/**
+ * createjs-compatible Text on a Pixi Text.
+ */
+export declare class Text extends DisplayObject {
+    readonly pixiText: PixiText;
+    private _text;
+    private _font;
+    private _color;
+    private _textAlign;
+    private _textBaseline;
+    private _lineHeight;
+    private _lineWidth;
+    private _maxWidth;
+    private _outline;
+    constructor(text?: string, font?: string, color?: string);
+    get text(): string;
+    set text(value: string);
+    get font(): string | null;
+    set font(value: string | null);
+    get color(): string | null;
+    set color(value: string | null);
+    get textAlign(): string;
+    set textAlign(value: string);
+    get textBaseline(): string;
+    set textBaseline(value: string);
+    get lineHeight(): number;
+    set lineHeight(value: number);
+    get lineWidth(): number | null;
+    set lineWidth(value: number | null);
+    get maxWidth(): number | null;
+    set maxWidth(value: number | null);
+    get outline(): number;
+    set outline(value: number);
+    private _updateText;
+    _setBlendMode(mode: PIXI.BLEND_MODES): void;
+    toString(): string;
+}
+/**
+ * createjs-compatible ColorFilter on a Pixi ColorMatrixFilter.
+ */
+export declare class ColorFilter {
+    readonly pixiFilter: PIXI.filters.ColorMatrixFilter;
+    private _values;
+    constructor(redMultiplier?: number, greenMultiplier?: number, blueMultiplier?: number, alphaMultiplier?: number, redOffset?: number, greenOffset?: number, blueOffset?: number, alphaOffset?: number);
+    get redMultiplier(): number;
+    set redMultiplier(value: number);
+    get greenMultiplier(): number;
+    set greenMultiplier(value: number);
+    get blueMultiplier(): number;
+    set blueMultiplier(value: number);
+    get alphaMultiplier(): number;
+    set alphaMultiplier(value: number);
+    get redOffset(): number;
+    set redOffset(value: number);
+    get greenOffset(): number;
+    set greenOffset(value: number);
+    get blueOffset(): number;
+    set blueOffset(value: number);
+    get alphaOffset(): number;
+    set alphaOffset(value: number);
+    private _set;
+    private _updateMatrix;
+    toString(): string;
+}
+/**
+ * Members ButtonHelper needs from its target (a MovieClip).
+ */
+export interface IButtonTarget extends Container {
+    paused: boolean;
+    actionsEnabled: boolean;
+    gotoAndPlay(frame: string | number): void;
+    gotoAndStop(frame: string | number): void;
+    _reset(): void;
+}
+/**
+ * createjs-compatible ButtonHelper: sends its target to the out / over /
+ * down frames on mouse events, and stops it on the out frame from the start.
+ */
+export declare class ButtonHelper {
+    readonly target: IButtonTarget;
+    overLabel: string | number;
+    outLabel: string | number;
+    downLabel: string | number;
+    play: boolean;
+    _isPressed: boolean;
+    _isOver: boolean;
+    _enabled: boolean;
+    private _originalReset;
+    constructor(target: IButtonTarget, outLabel?: string | number | null, overLabel?: string | number | null, downLabel?: string | number | null, play?: boolean, hitArea?: IButtonTarget | null, hitLabel?: string | number | null);
+    get enabled(): boolean;
+    set enabled(value: boolean);
+    handleEvent(event: Event): void;
+    toString(): string;
+}
+export {};

package/types/player/semver.d.ts

@@ -0,0 +1,27 @@
+/**
+ * Semantic version numbers and ranges, as far as the version checks of
+ * definitions and runtime content need them: versions are MAJOR.MINOR.PATCH,
+ * and ranges are written as npm writes them (`1.2.3`, `1.x`, `^1.2.0`,
+ * `~1.2.0`, `>=1.0.0 <2.0.0`, `0.x || 1.x`). Pre-release tags are not handled.
+ */
+type TVersion = [number, number, number];
+/** A version as its three numbers, or null when it is not MAJOR.MINOR.PATCH */
+export declare function parseVersion(text: string): TVersion | null;
+/** -1, 0 or 1 as a is lower than, the same as or higher than b (both have to be versions) */
+export declare function compareVersions(a: string, b: string): number;
+/** Whether a version is in a range (npm's notation, see above); a range not understood throws */
+export declare function satisfies(version: string, range: string): boolean;
+/**
+ * Whether data a reader is given can be read: `error` when its writer's
+ * version is outside the range the reader reads, `warning` when it is in the
+ * range but newer than the version the reader knows of (the data may hold
+ * what the reader does not know and leaves out). Both null when it reads.
+ */
+export interface IVersionCheck {
+    error: string | null;
+    warning: string | null;
+    /** With an error: whether the writer is newer than the reader (update the reader) or older (write the data again) */
+    newer: boolean;
+}
+export declare function checkVersion(version: string, range: string, known: string): IVersionCheck;
+export {};

package/types/player/transform.d.ts

@@ -0,0 +1,32 @@
+import * as PIXI from 'pixi.js';
+/**
+ * A Pixi Transform whose rotation and skew follow createjs.
+ *
+ * - The createjs values (degrees) are kept as written, so that reading them
+ *   back gives exactly what was written (a degrees -> radians -> degrees round
+ *   trip does not)
+ * - Pixi's own fields carry the same values in Pixi's terms (rotation in
+ *   radians, skew.x = -skewX, skew.y = skewY, all in radians), so code that
+ *   uses the Pixi node sees consistent values. A write made through Pixi
+ *   (node.rotation, node.skew) is taken over as the new createjs value
+ * - The local matrix is built the createjs way: skew x (rotation x scale),
+ *   i.e. the object is rotated first and then skewed. Pixi composes rotation
+ *   and skew the other way round (skewed, then rotated as a whole); the two
+ *   agree only while the rotation is 0 or skewX equals skewY. Published
+ *   content is the reference, so createjs's composition is used
+ */
+export declare class CjsTransform extends PIXI.Transform {
+    /** createjs rotation, in degrees */
+    degRotation: number;
+    /** createjs skewX / skewY, in degrees */
+    degSkewX: number;
+    degSkewY: number;
+    /** The radians last written to the Pixi fields for the values above */
+    private _radRotation;
+    private _radSkewX;
+    private _radSkewY;
+    setRotation(degrees: number): void;
+    setSkewX(degrees: number): void;
+    setSkewY(degrees: number): void;
+    protected updateSkew(): void;
+}

package/types/player/version.d.ts

@@ -0,0 +1,2 @@
+/** The version of this package (written in from package.json when the package is built) */
+export declare const VERSION: string;