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

package/types/generator/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/generator/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;

package/types/player/animate-container.d.ts

@@ -0,0 +1,71 @@
+import * as PIXI from 'pixi.js';
+import { DisplayObject } from './display';
+/**
+ * Plays the content roots put on a Pixi container at their content's frame
+ * rate (the rate the content was published with). AnimateContainer is a Pixi
+ * container with one; a container of another framework can hold one too.
+ *
+ * Each handleTick call owes every root `delta x speed x fps / 60` frames
+ * (delta being the ticker's: 1 per frame of a 60 fps display) and plays the
+ * whole frames owed. With `smooth`, the frames played follow a steady clock
+ * instead of the deltas themselves: it advances by the usual delta of the
+ * display (the median of the latest ones) on every call, so that small changes
+ * of the delta do not play a frame early or late (0 frames on one call and 2
+ * on the next), and it is pulled toward the real time a little on every call,
+ * and set to it when they are a frame apart (a frame of the display was
+ * missed), so that the content keeps the real time. One frame is createjs's
+ * tick phase followed by its resolve phase. The first call after a root is put
+ * on only settles it on its first frame.
+ */
+export declare class AnimateController {
+    /** Playback speed (1 is the content's own frame rate) */
+    speed: number;
+    /** Whether one call may play more than one frame (when the display runs slower than the content) */
+    overSpeed: boolean;
+    /** Whether frames are played by a steady clock, so that small changes of the delta do not make the playing uneven */
+    smooth: boolean;
+    private readonly _container;
+    private _targets;
+    private _nextId;
+    /** The latest deltas (a ring of DELTA_SAMPLES) */
+    private _deltas;
+    private _nextDelta;
+    /** @param container The container the roots are put on */
+    constructor(container: PIXI.Container);
+    handleTick(delta: number): void;
+    /** Records a delta and gives the median of the latest ones */
+    private _usualDelta;
+    /** Puts a content object on the container; a MovieClip plays from then on */
+    addCreatejs<T extends DisplayObject>(obj: T): T;
+    addCreatejsAt<T extends DisplayObject>(obj: T, index: number): T;
+    removeCreatejs<T extends DisplayObject>(obj: T): T;
+    /**
+     * A MovieClip is played while its node is on the container. Coming from
+     * another parent, it starts over from its first frame.
+     */
+    private _register;
+}
+/**
+ * A Pixi container that plays the content roots put on it at their
+ * content's frame rate (see AnimateController).
+ *
+ * Call handleTick from the application's ticker:
+ * `app.ticker.add(container.handleTick, container)`.
+ */
+export declare class AnimateContainer extends PIXI.Container {
+    private readonly _controller;
+    /** Playback speed (1 is the content's own frame rate) */
+    get speed(): number;
+    set speed(value: number);
+    /** Whether one call may play more than one frame (when the display runs slower than the content) */
+    get overSpeed(): boolean;
+    set overSpeed(value: boolean);
+    /** Whether frames are played by a steady clock, so that small changes of the delta do not make the playing uneven */
+    get smooth(): boolean;
+    set smooth(value: boolean);
+    handleTick(delta: number): void;
+    /** Puts a content object on this container; a MovieClip plays from then on */
+    addCreatejs<T extends DisplayObject>(obj: T): T;
+    addCreatejsAt<T extends DisplayObject>(obj: T, index: number): T;
+    removeCreatejs<T extends DisplayObject>(obj: T): T;
+}

package/types/player/content.d.ts

@@ -0,0 +1,170 @@
+import * as PIXI from 'pixi.js';
+import { DisplayObject, Container } from './display';
+import { Rectangle } from './geom';
+import { Event, EventDispatcher } from './events';
+import { MovieClip, TScript, TWriter, TMemberWriter } from './movieclip';
+import { Shape, Graphics, Sprite, SpriteSheet, Bitmap, Text, ColorFilter, ButtonHelper, ITextureSource, IImageAsset } from './objects';
+import { IRuntimeData, IRuntimeMovieClipDef, IRuntimeTweenDef, IRuntimeSlotDef, ISpriteDef, IBitmapDef } from './data';
+export type TMovieClipClass = new (mode?: string | null, startPosition?: number | null, loop?: boolean | number | null) => MovieClip;
+export type TSpriteClass = new () => Sprite;
+export type TBitmapClass = new () => Bitmap;
+export type TSymbolClass = TMovieClipClass | TSpriteClass | TBitmapClass;
+/**
+ * The symbol classes of a content by symbol id: what published code calls `lib`.
+ */
+export interface ILibrary {
+    [id: string]: TSymbolClass;
+}
+/**
+ * The createjs-compatible names frame scripts reach as `cjs` / `createjs`.
+ */
+export declare const namespace: {
+    DisplayObject: typeof DisplayObject;
+    Container: typeof Container;
+    MovieClip: typeof MovieClip;
+    Shape: typeof Shape;
+    Graphics: typeof Graphics;
+    Sprite: typeof Sprite;
+    SpriteSheet: typeof SpriteSheet;
+    Bitmap: typeof Bitmap;
+    Text: typeof Text;
+    ColorFilter: typeof ColorFilter;
+    ButtonHelper: typeof ButtonHelper;
+    Event: typeof Event;
+    EventDispatcher: typeof EventDispatcher;
+    Rectangle: typeof Rectangle;
+    Point: typeof PIXI.Point;
+};
+export type TNamespace = typeof namespace;
+/** What frame scripts get for the template's global playSound: nothing is played */
+export interface ISilentSound {
+    paused: boolean;
+    volume: number;
+    addEventListener(): void;
+    removeEventListener(): void;
+    on(): void;
+    stop(): void;
+    play(): void;
+}
+export interface IGeneratedContent {
+    data: IRuntimeData;
+    scripts: TScript[];
+    writers: TWriter[];
+    memberWriters: TMemberWriter[];
+}
+/**
+ * What runtime content exports: given the names frame scripts refer
+ * to, it returns the content's data and its frame scripts (as code, closed
+ * over those names). exportRoot and stage are passed as undefined: they are
+ * the template's root and stage, which a player of any symbol does not have.
+ */
+export type TContentFactory = (cjs: TNamespace, createjs: TNamespace, lib: ILibrary, exportRoot: undefined, stage: undefined, playSound: () => ISilentSound) => IGeneratedContent;
+export interface IContentAssets {
+    /** Textures of the manifest images (sprite sheet atlases included), by manifest id */
+    images?: {
+        [id: string]: PIXI.Texture;
+    };
+}
+/** A value of the published lib.properties (width, height, fps, color, ...) */
+export type TContentProperty = number | string | boolean | null;
+export interface IContentProperties {
+    [key: string]: TContentProperty;
+}
+/**
+ * A loaded content, as the application uses it.
+ */
+export interface IContent {
+    /** The composition id (lib.properties.id of the published content) */
+    readonly id: string;
+    /** The symbol classes by symbol name: what frame scripts reach as `lib` */
+    readonly lib: ILibrary;
+    /** The values of the published lib.properties (its lists, such as the manifest, left out) */
+    readonly properties: Readonly<IContentProperties>;
+    /**
+     * An instance of a symbol for the application to place, set up as the HTML
+     * template sets up the root it creates.
+     */
+    create(id: string): DisplayObject;
+}
+/** A MovieClip symbol as the player builds its instances from: its slots with every field */
+interface IMovieClipPlan extends Omit<IRuntimeMovieClipDef, 'slots' | 'tweens'> {
+    slots: IRuntimeSlotDef[];
+    tweens: IRuntimeTweenDef[];
+}
+/**
+ * A content: the symbol classes built from generated data, sharing one
+ * definition per symbol. Not part of the API: applications get an IContent.
+ * @internal
+ */
+export declare class Content implements ITextureSource {
+    readonly data: IRuntimeData;
+    readonly scripts: TScript[];
+    readonly writers: TWriter[];
+    readonly memberWriters: TMemberWriter[];
+    readonly lib: ILibrary;
+    readonly images: {
+        [id: string]: IImageAsset;
+    };
+    /** One Graphics per drawing of the content, shared by every symbol that shows it */
+    readonly graphics: Graphics[];
+    readonly spriteSheets: {
+        [name: string]: SpriteSheet;
+    };
+    private readonly _frameAssets;
+    constructor(factory: TContentFactory, assets?: IContentAssets);
+    /**
+     * Sets the textures of the content's images (by manifest id) and the sprite
+     * sheets cut from them. Done before any instance is made: the constructor's
+     * assets, or the textures a loader read for the content afterwards.
+     */
+    _applyImages(textures: {
+        [id: string]: PIXI.Texture;
+    }): void;
+    image(id: string): PIXI.Texture | null;
+    frame(sheet: string, index: number): PIXI.Texture | null;
+    imageAsset(id: string): IImageAsset | null;
+    /** The image a frame of a sheet is drawn into for a bitmap fill (named after the atlas and the frame) */
+    frameAsset(sheet: string, index: number): IImageAsset | null;
+    /**
+     * An instance of a symbol for the application to place, set up as the HTML
+     * template sets up the root it creates: a clip that re-caches its children's
+     * color effects (it has a filterCacheList) gets the filter cache handling,
+     * which published code otherwise gets from the symbol that creates it (an
+     * instance made by `new lib[id]()` in a frame script gets none, as in
+     * CreateJS). The handling does not change what the player draws (it draws
+     * color effects without caches); it keeps the instance's state the
+     * template's.
+     */
+    create(id: string): DisplayObject;
+    private _movieClipClass;
+    private _spriteClass;
+    private _bitmapClass;
+    private _sheet;
+    private _image;
+    _applySprite(sprite: Sprite, def: ISpriteDef | null): void;
+    _applyBitmap(bitmap: Bitmap, def: IBitmapDef | null): void;
+    private _createSlot;
+    /**
+     * Builds an instance of a MovieClip symbol: what the published
+     * constructor builds, from the shared definition.
+     */
+    _populate(self: MovieClip, def: IMovieClipPlan, graphics: Graphics[]): void;
+}
+/**
+ * What the application gets of a content: the content itself stays out of
+ * reach, the methods closing over it.
+ */
+export declare function contentInterface(content: Content): IContent;
+/**
+ * Plays one frame of a display tree the way createjs does on a stage update:
+ * the tick phase (playheads advance, children in reverse order, tick
+ * listeners), then the resolve phase (each MovieClip settles its timeline,
+ * children in reverse order).
+ */
+export declare function tick(root: DisplayObject, event?: Event): void;
+/**
+ * The resolve phase alone: each MovieClip settles its timeline (children in
+ * reverse order), without playing a frame.
+ */
+export declare function resolveState(node: DisplayObject): void;
+export {};

package/types/player/data.d.ts

@@ -0,0 +1,141 @@
+/**
+ * The data of runtime content (what the generator writes and the player reads): the definition
+ * extracted by @tawaship/animate-data-converter, with every frame script
+ * taken out of the data and referenced by its index in the runtime content's
+ * script list (the scripts themselves are code in the runtime content), and with
+ * the writes of each tween and of each instance's initial values compiled
+ * into writer functions (code in the runtime content as well, referenced by index).
+ * Drawings are gathered into one table for the whole content, identical
+ * ones merged, and a symbol refers to them by index.
+ */
+import type { IMovieClipSymbolDef, ISpriteSymbolDef, IBitmapSymbolDef, ITweenDef, IPropMapDef, ISlotDef, IManifestEntryDef, ISpriteSheetDef, IGraphicsCommandDef, IStateEntryDef, TDataValue, TFrameValue } from '@tawaship/animate-data-converter';
+import { TEase } from './ease';
+/** A kind of drawing command: its type and the names of its props, in order */
+export type TRuntimeCommandKind = [string, string[]];
+/** A drawing command as written in runtime content: the index of its kind, then its props' values in the kind's order */
+export type TRuntimeCommand = TDataValue[];
+/** A drawing as written in runtime content */
+export interface IRuntimeGraphicsData {
+    commands: TRuntimeCommand[];
+}
+/** A drawing's commands as the player draws them, from their written form */
+export declare function commandsOf(kinds: TRuntimeCommandKind[], graphics: IRuntimeGraphicsData): IGraphicsCommandDef[];
+export type { ISlotDef, ITweenDef, IStateEntryDef, IGraphicsDef, IGraphicsCommandDef, ISpriteDef, IBitmapDef, IFilterDef, ICacheDef, IButtonDef, IFilterCacheEntryDef, IRectDef, IDataMap, IPropMapDef, IManifestEntryDef, ISpriteSheetDef, ILabelDef, IMemberDef, TTargetDef, TFrameValue, TDataValue, ISpriteSymbolDef, IBitmapSymbolDef } from '@tawaship/animate-data-converter';
+/**
+ * The pixi-animate-runtime versions whose runtime content this player plays
+ * (npm's range notation). Raised when the player stops playing runtime
+ * content older versions made.
+ */
+export declare const RUNTIME_CONTENT_RANGE = "0.x";
+export interface IRuntimeActionDef {
+    /** Timeline position the action sits on */
+    position: number;
+    /** Index into the runtime content's script list */
+    script: number;
+    params: TFrameValue[] | null;
+}
+export interface IRuntimeTweenDef extends Omit<ITweenDef, 'actions' | 'frames'> {
+    actions: IRuntimeActionDef[];
+    /** The tween's distinct frame values (each the values of its props, in order) */
+    values: TFrameValue[][];
+    /** For every position, the index of its values in values (a position holding the same values as another shares them) */
+    frames: number[];
+    /**
+     * Index into the runtime content's writer list: the function that writes a frame's
+     * values (values[frames[position]]) to the target, one property after another by
+     * name (null when the tween writes no property)
+     */
+    writer: number | null;
+}
+/**
+ * A slot as the player uses it. Its initial values are in code only (the
+ * writer), not in the data.
+ */
+/**
+ * A frame value as written in runtime content: a display list (`state`) may
+ * give an entry that places a slot as it is (no props) as the slot's index
+ */
+export type TRuntimeFrameValue = TFrameValue | Array<IStateEntryDef | number>;
+/**
+ * A position, or a stretch of positions, of a tween as written in runtime
+ * content: the index of the position's values, or an interpolated stretch
+ * [from, to, length, ease] whose positions run from values[from] toward
+ * values[to] (the position after the stretch) as CreateJS interpolates a
+ * step with that ease (see interpolated)
+ */
+export type TRuntimeFrameRef = number | [number, number, number, string];
+/** A tween as written in runtime content (tweenOf makes its values for every position) */
+export interface IRuntimeTweenData extends Omit<IRuntimeTweenDef, 'values' | 'frames'> {
+    values: TRuntimeFrameValue[][];
+    frames: TRuntimeFrameRef[];
+}
+/**
+ * The values at a position of a step, as CreateJS's Tween computes them: the
+ * ratio of the position in the step, eased, then each value from its start
+ * toward its end (a value that is not a number, or does not change, keeps its
+ * start until the eased ratio reaches 1).
+ */
+export declare function interpolated(from: TFrameValue[], to: TFrameValue[], position: number, length: number, ease: TEase | null): TFrameValue[];
+/**
+ * A tween with the values of every position: its display lists (the values of
+ * its `state` prop) as entries, and its interpolated stretches computed (each
+ * position of a stretch gets values of its own)
+ */
+export declare function tweenOf(data: IRuntimeTweenData): IRuntimeTweenDef;
+export interface IRuntimeSlotDef extends Omit<ISlotDef, 'init'> {
+    /** Index into the runtime content's writer list: the function that writes the slot's initial values (initValues) */
+    initWriter: number | null;
+    /** The slot's initial values, in the order its writer writes them */
+    initValues: TFrameValue[] | null;
+}
+/** The values a slot's fields have when runtime content leaves them out */
+export declare const SLOT_DEFAULTS: Omit<IRuntimeSlotDef, 'kind'>;
+/**
+ * A slot template as written in runtime content: its kind, and the fields not
+ * at their defaults (SLOT_DEFAULTS); its initial values are the slot's own
+ */
+export type TRuntimeSlotData = Pick<IRuntimeSlotDef, 'kind'> & Partial<Omit<IRuntimeSlotDef, 'kind' | 'initValues'>>;
+/**
+ * A slot as written in a symbol: the index of its template in the content's
+ * slotTemplates, with its initial values when it has some
+ */
+export type TRuntimeSlotRef = number | [number, TFrameValue[]];
+/** A slot from its template (the fields left out at their defaults) and its initial values */
+export declare function slotOf(templates: TRuntimeSlotData[], ref: TRuntimeSlotRef): IRuntimeSlotDef;
+export interface IRuntimeMovieClipDef extends Omit<IMovieClipSymbolDef, 'tweens' | 'slots' | 'graphics' | 'members'> {
+    /** The slots as written (templates and initial values; slotOf makes them whole) */
+    slots: TRuntimeSlotRef[];
+    /** The tweens as written (display lists with slot indexes; tweenOf turns them back into entries) */
+    tweens: IRuntimeTweenData[];
+    /**
+     * Index into the runtime content's member writer list: the function that
+     * gives an instance its named children (`this.instance = ...`), or null
+     * when it has none
+     */
+    memberWriter: number | null;
+    /**
+     * The symbol's drawings as indexes into the content's drawing table
+     * (graphics[n] is the drawing the symbol's slots and tween values call n)
+     */
+    graphics: number[];
+}
+export type TRuntimeSymbolDef = IRuntimeMovieClipDef | ISpriteSymbolDef | IBitmapSymbolDef;
+export interface IRuntimeData {
+    /** The version of pixi-animate-runtime that generated the runtime content */
+    runtimeVersion: string;
+    /** Primitive entries of the published lib.properties (width, height, fps, color, ...) */
+    properties: IPropMapDef;
+    /** Images of the published manifest (sounds are left out) */
+    images: IManifestEntryDef[];
+    /** The published lib.ssMetadata */
+    spriteSheets: ISpriteSheetDef[];
+    /** Every drawing of the content, identical ones merged (shared by every symbol that shows them); commandsOf reads them */
+    graphics: IRuntimeGraphicsData[];
+    /** The kinds of the drawings' commands (a type and the names of its props) */
+    commandKinds: TRuntimeCommandKind[];
+    /** The slots of every symbol but their initial values, identical ones merged */
+    slotTemplates: TRuntimeSlotData[];
+    symbols: {
+        [id: string]: TRuntimeSymbolDef;
+    };
+}

package/types/player/display.d.ts

@@ -0,0 +1,186 @@
+import * as PIXI from 'pixi.js';
+import { Event, EventDispatcher } from './events';
+import { Rectangle } from './geom';
+/**
+ * A Pixi node owned by a createjs-compatible display object.
+ */
+export interface IOwnedNode extends PIXI.Container {
+    owner: DisplayObject | null;
+}
+export declare class PixiContainer extends PIXI.Container implements IOwnedNode {
+    owner: DisplayObject | null;
+}
+/** A hit area nothing is inside: Pixi's hit test skips a node with it and the node's children */
+export declare const NO_HIT_AREA: PIXI.Rectangle;
+/**
+ * Members a filter shown through a display object has to provide.
+ */
+export interface IFilterLike {
+    pixiFilter: PIXI.Filter;
+}
+export interface ICacheState {
+    x: number;
+    y: number;
+    width: number;
+    height: number;
+    scale: number;
+}
+/**
+ * createjs-compatible display object: a window onto a Pixi node.
+ *
+ * The values both have in common live on the Pixi node only (x / y on
+ * position, scaleX / scaleY on scale, regX / regY on pivot, alpha, visible),
+ * read and written through accessors, so a write through the Pixi node and a
+ * write through this object are the same write. Members that mean different
+ * things in createjs and Pixi keep the createjs meaning here (rotation and
+ * skew in degrees, mask, filters, parent); the Pixi node keeps the Pixi one.
+ */
+export declare class DisplayObject extends EventDispatcher {
+    /** The Pixi node this object shows */
+    readonly pixi: IOwnedNode;
+    readonly id: number;
+    parent: Container | null;
+    tickEnabled: boolean;
+    mouseEnabled: boolean;
+    cursor: string | null;
+    hitArea: DisplayObject | null;
+    shadow: null;
+    snapToPixel: boolean;
+    /**
+     * Kept off the display list by the timeline (published code sets it on masks
+     * and absent instances). createjs reads it only when its timeline places
+     * children: it does not affect drawing (an _off object on a display list is drawn)
+     */
+    /** createjs leaves it unset (undefined) until the timeline or published code sets it */
+    private _offValue;
+    private _name;
+    private _mask;
+    private _filters;
+    private _compositeOperation;
+    /** The composite operation in effect on the parent (createjs draws children under it) */
+    private _inheritedComposite;
+    /** The cache createjs would draw through (filters show in Pixi without one) */
+    bitmapCache: ICacheState | null;
+    /** Set only when the symbol has them (createjs leaves them undefined otherwise) */
+    nominalBounds?: Rectangle | null;
+    frameBounds?: Rectangle[] | null;
+    _bounds: Rectangle | null;
+    /** The parent whose Pixi node holds this object's mask node */
+    _maskHost: Container | null;
+    /** The objects this object masks (while they are on a display list) */
+    _maskTargets: DisplayObject[];
+    constructor(pixi: IOwnedNode);
+    get _eventParent(): EventDispatcher | null;
+    private get _transform();
+    get x(): number;
+    set x(value: number);
+    get y(): number;
+    set y(value: number);
+    get scaleX(): number;
+    set scaleX(value: number);
+    get scaleY(): number;
+    set scaleY(value: number);
+    get regX(): number;
+    set regX(value: number);
+    get regY(): number;
+    set regY(value: number);
+    get rotation(): number;
+    set rotation(value: number);
+    get skewX(): number;
+    set skewX(value: number);
+    get skewY(): number;
+    set skewY(value: number);
+    get alpha(): number;
+    set alpha(value: number);
+    get visible(): boolean;
+    set visible(value: boolean);
+    get name(): string | null;
+    set name(value: string | null);
+    get _off(): boolean | undefined;
+    set _off(value: boolean | undefined);
+    get compositeOperation(): string | null;
+    set compositeOperation(value: string | null);
+    /**
+     * The composite operation createjs draws this object with: its own, or else
+     * the nearest ancestor's (createjs sets it on the context and draws the
+     * children under it, each child saving and restoring the context)
+     */
+    _effectiveComposite(): string | null;
+    /** Told by the parent when the composite operation in effect on it changes */
+    _setInheritedComposite(value: string | null): void;
+    /**
+     * Pixi blends per drawing node (a container has no blend mode of its own),
+     * so the composite operation in effect is set on this object's drawing node
+     * and handed down to the children
+     */
+    _applyComposite(): void;
+    get mask(): DisplayObject | null;
+    set mask(value: DisplayObject | null);
+    get filters(): IFilterLike[] | null;
+    set filters(value: IFilterLike[] | null);
+    /** Blend mode for the Pixi node(s) that draw this object */
+    _setBlendMode(mode: PIXI.BLEND_MODES): void;
+    /**
+     * The node is drawn unless Pixi uses it as a mask, or it is in a parent's
+     * node only to carry the mask shape of a sibling (a createjs mask is not on
+     * any display list and is not drawn itself)
+     */
+    _updateRenderable(): void;
+    /** Whether this object clips when used as a mask (createjs clips only with a non-empty Graphics) */
+    _clipsAsMask(): boolean;
+    /** The node Pixi masks with when this object is a mask */
+    _pixiMaskNode(): PIXI.Container | null;
+    /** Called when this object stops being some object's Pixi mask */
+    _releaseMaskNode(): void;
+    /** Sets the Pixi mask from the createjs one: Pixi masks only while the createjs mask would clip */
+    _updatePixiMask(): void;
+    setTransform(x?: number, y?: number, scaleX?: number, scaleY?: number, rotation?: number, skewX?: number, skewY?: number, regX?: number, regY?: number): this;
+    set(props: {
+        [key: string]: string | number | boolean | null;
+    }): this;
+    isVisible(): boolean;
+    cache(x: number, y: number, width: number, height: number, scale?: number): void;
+    updateCache(): void;
+    uncache(): void;
+    setBounds(x: number | null, y?: number, width?: number, height?: number): void;
+    getChildDepth(): number;
+    /** createjs tick phase: dispatches the tick event to listeners */
+    _tick(event: Event): void;
+    toString(): string;
+}
+/**
+ * createjs-compatible Container. The Pixi node's children are the display
+ * list's nodes in the same order, followed by the nodes of the masks the
+ * children use (a createjs mask is drawn in its target's parent space, so
+ * its node lives in the parent's node).
+ */
+export declare class Container extends DisplayObject {
+    children: DisplayObject[];
+    tickChildren: boolean;
+    mouseChildren: boolean;
+    /** Mask nodes held in this container's node, by the child that uses them */
+    private _maskNodes;
+    constructor(pixi?: IOwnedNode);
+    get numChildren(): number;
+    addChild(...children: DisplayObject[]): DisplayObject | null;
+    addChildAt(child: DisplayObject, index: number): DisplayObject;
+    removeChild(...children: DisplayObject[]): boolean;
+    removeChildAt(...indexes: number[]): boolean;
+    removeAllChildren(): void;
+    getChildAt(index: number): DisplayObject | undefined;
+    getChildByName(name: string): DisplayObject | null;
+    getChildIndex(child: DisplayObject): number;
+    setChildIndex(child: DisplayObject, index: number): void;
+    swapChildrenAt(index1: number, index2: number): void;
+    swapChildren(child1: DisplayObject, child2: DisplayObject): void;
+    sortChildren(compare: (a: DisplayObject, b: DisplayObject) => number): void;
+    contains(child: DisplayObject | null): boolean;
+    _removeChildAt(index: number, silent?: boolean): boolean;
+    /** Puts the node of a child's mask into this container's node, and sets it as the Pixi mask */
+    _attachMask(child: DisplayObject): void;
+    _detachMask(child: DisplayObject): void;
+    _applyComposite(): void;
+    /** createjs tick phase: children in reverse order (live array), then this object's listeners */
+    _tick(event: Event): void;
+    toString(): string;
+}

package/types/player/ease.d.ts

@@ -0,0 +1,11 @@
+/**
+ * The eases of CreateJS (createjs.Ease), computed as CreateJS computes them,
+ * by name. Runtime content names the ease of an interpolated stretch of a
+ * tween; the player computes the stretch's values with it once, when a symbol's
+ * class is made. `get:<amount>` is Ease.get(amount) (Animate's classic ease).
+ */
+export type TEase = (t: number) => number;
+/** The ease runtime content names (null for a name the player does not know) */
+export declare function easeOf(id: string): TEase | null;
+/** The eases the generator tries for a stretch of a tween, by name: the named ones, then Ease.get(-1 .. 1) in hundredths */
+export declare function easeIds(): string[];

package/types/player/events.d.ts

@@ -0,0 +1,60 @@
+/**
+ * createjs-compatible events: Event and EventDispatcher, with the capture,
+ * target and bubble phases createjs dispatches through the parent chain.
+ */
+export interface IEventHandlerObject {
+    handleEvent(event: Event): void;
+}
+/** Data passed to a listener added with on() */
+export type TEventData = string | number | boolean | object | null | undefined;
+export type TEventListener = ((event: Event, data?: TEventData) => void) | IEventHandlerObject;
+interface IListenerMap {
+    [type: string]: TEventListener[];
+}
+export declare class Event {
+    type: string;
+    target: EventDispatcher | null;
+    currentTarget: EventDispatcher | null;
+    eventPhase: number;
+    bubbles: boolean;
+    cancelable: boolean;
+    timeStamp: number;
+    defaultPrevented: boolean;
+    propagationStopped: boolean;
+    immediatePropagationStopped: boolean;
+    removed: boolean;
+    /** Time since the last tick, for tick events (createjs Ticker events carry it) */
+    delta: number | undefined;
+    paused: boolean | undefined;
+    constructor(type: string, bubbles?: boolean, cancelable?: boolean);
+    preventDefault(): void;
+    stopPropagation(): void;
+    stopImmediatePropagation(): void;
+    remove(): void;
+    clone(): Event;
+    set(props: {
+        [key: string]: string | number | boolean | null;
+    }): Event;
+    toString(): string;
+}
+export declare class EventDispatcher {
+    _listeners: IListenerMap | null;
+    _captureListeners: IListenerMap | null;
+    /** The parent the bubble and capture phases walk through (a display object's parent) */
+    get _eventParent(): EventDispatcher | null;
+    addEventListener(type: string, listener: TEventListener, useCapture?: boolean): TEventListener;
+    on(type: string, listener: TEventListener, scope?: object, once?: boolean, data?: TEventData, useCapture?: boolean): TEventListener;
+    removeEventListener(type: string, listener: TEventListener, useCapture?: boolean): void;
+    off(type: string, listener: TEventListener, useCapture?: boolean): void;
+    removeAllEventListeners(type?: string): void;
+    dispatchEvent(eventOrType: Event | string, bubbles?: boolean, cancelable?: boolean): boolean;
+    hasEventListener(type: string): boolean;
+    willTrigger(type: string): boolean;
+    /**
+     * Phase 1 is capture, 2 the target, 3 bubbling. At the target, the capture
+     * listeners run first and then the others (createjs runs the target phase
+     * twice, the second time as phase 2.1, which reads the non-capture listeners).
+     */
+    _dispatchEvent(event: Event, phase: number): void;
+}
+export {};