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

package/dist-skills/animate-data-converter-guide/SKILL.md

@@ -0,0 +1,86 @@
+---
+name: animate-data-converter-guide
+description: Use this skill whenever the user asks to extract, inspect, or debug the data that @tawaship/animate-data-converter extracts from Adobe Animate HTML5 Canvas (CreateJS) publish output — the engine-independent symbol and timeline definitions (IDefinition). Trigger on any mention of 'animate-data-converter', 'extractPublishedFile', 'extractPublished', 'expand', 'compact', 'IDefinition', 'converterVersion', definition JSON files, or unsupported-feature 'issues' reported for Animate content. To play content on PixiJS, use the pixi-animate-runtime-guide skill instead (its generator runs this converter for you); with Pixim.js, the pixim-animate-runtime-guide skill.
+---
+
+# @tawaship/animate-data-converter development skill
+
+Supported versions: **`^0.1.0`** (written against `0.1.0`).
+
+First determine the installed version (`node_modules/@tawaship/animate-data-converter/package.json`). If it is outside the supported range, **treat the type definitions in node_modules as authoritative** and follow them wherever they disagree with this skill.
+
+The content is assumed to be published by **Adobe Animate 24.0.15** for HTML5 Canvas, the only version checked: this package depends on the form of the published JavaScript. If the user's content comes from another version of Animate and something does not work, mention this before looking for other causes.
+
+## Overview
+
+`@tawaship/animate-data-converter` reads the JavaScript that Adobe Animate publishes for HTML5 Canvas and extracts every symbol and its timeline as plain data (JSON-compatible), one definition per symbol, shared by every instance. A player for a specific engine builds on this data, so content can be played without CreateJS or the published code at play time.
+
+- It runs in **Node.js 18 or later only**, at development time. Never suggest running it in the browser
+- It reads only the published JavaScript. Images and sounds are not read, and CreateJS 1.0.0 comes with the package
+- Most users do not call it directly: `@tawaship/pixi-animate-runtime`'s generator (`npx --no-install @tawaship/pixi-animate-runtime`) runs it. Use the converter directly only to keep definitions as files, to inspect them, or to build a player of your own
+
+## Type definition files
+
+**Before writing code that uses this package, check the corresponding type definition file.** Read them from the package installed in the project (`node_modules/@tawaship/animate-data-converter/types/`); that is the single source of truth.
+
+| What | Type definition file |
+|---|---|
+| Entry point (everything exported) | `types/index.d.ts` |
+| The definition (`IDefinition` and the types it is made of) | `types/types.d.ts` |
+| `extractPublishedFile`, `extractPublished` | `types/load.d.ts` |
+| `expand`, `compact`, `SLOT_DEFAULTS` | `types/compact.d.ts` |
+| `extract` | `types/extract.d.ts` |
+| The CreateJS surface `extract` reads | `types/createjs.d.ts` |
+
+## Basic usage
+
+### Command line
+
+```sh
+npx --no-install @tawaship/animate-data-converter game.js --out game.json --pretty
+```
+
+- `-o, --out <file>`: where to write (standard output without it). `-p, --pretty`: indented JSON. `-e, --expanded`: the expanded form instead of the compact one. `-f, --force`: write even with unsupported features. `-h, --help`: the usage
+- Exit code `1` when the content uses unsupported features (each one is listed, nothing is written unless `--force` is given), `2` when the file cannot be read or is not Animate HTML5 Canvas output
+
+### API
+
+```js
+const { extractPublishedFile } = require('@tawaship/animate-data-converter');
+
+extractPublishedFile('game.js').then(definition => {
+  definition.issues.forEach(issue => console.warn(issue.symbol, issue.message));
+});
+```
+
+The published code runs in a sandbox (QuickJS, a JavaScript engine compiled to WebAssembly, given nothing of the host), so extraction is asynchronous. Still tell the user to convert only content they trust (see the README).
+
+| Function | Use it for |
+|---|---|
+| `extractPublishedFile(path)` | Extracting from a file (returns a promise) |
+| `extractPublished({ published })` | Extracting from source text already in hand (returns a promise) |
+| `extract(createjs, source)` | Extracting from content already running in an environment you set up |
+| `expand(definition)` / `compact(expanded)` | Converting between the compact form (what extraction gives) and the expanded form (every value as it is) |
+
+When calling `extract()` on an environment of your own, images created while symbols are constructed must report that they have loaded as soon as an `onload` handler is assigned; otherwise bitmap fills from sprite sheets are missing from the definition. Prefer `extractPublished()`, which runs the published code in its sandbox (QuickJS) and does this.
+
+## What the definition holds
+
+The definition is extracted in its **compact form** (`form: 'compact'`): every value kept, written once (drawings in the content's `graphics` with `commandKinds`, slots as `slotTemplates` plus initial values, each tween's distinct `values` with the index of every position's values in `frames`). `expand()` gives the **expanded form** (`form: 'expanded'`), every value where it applies; read `IExpandedDefinition` for that. The README's "Reading a definition" explains both. pixi-animate-runtime's generator takes the compact form only.
+
+
+- `symbols`: every symbol of the published `lib`, under its library name (non-ASCII names kept as they are). Published content has no root of its own; any symbol can be played as a root (the published HTML picks one)
+- For a movie clip: labels, length, the display objects it owns with their initial state, masks, buttons, color effects, caching, and its tweens with **the exact value of every controlled property at every frame** (not approximated)
+- Frame scripts as their **source text**, unchanged. They are not run or rewritten
+- `manifest`, `spriteSheets`, `properties` (size, frame rate, background color), `issues`
+- `converterVersion`: the converter version that extracted it. A reader of kept definition files can tell from it whether it knows their form
+
+## Important notes
+
+### Unsupported content is reported, not guessed
+
+When `issues` is not empty, the content uses something outside the supported range (the Animate camera / "Advanced Layers", filters other than color effects, event listeners added by symbol code, hand-written looping/reversed tweens, non-plain frame script functions, display objects other than MovieClip/Shape/Sprite/Bitmap/Text). Report the listed issues to the user and suggest changing the Animate document (for the camera: delete the camera layer and publish again). Do not suggest `--force` as a fix: it only writes the data anyway.
+
+### Publish again → extract again
+
+The definition is a snapshot of one publish. After the content is published again from Animate, extract (or generate) again.

package/dist-skills/pixi-animate-runtime-guide/SKILL.md

@@ -0,0 +1,146 @@
+---
+name: pixi-animate-runtime-guide
+description: Use this skill whenever the user asks to create, edit, or debug content using @tawaship/pixi-animate-runtime — a player that plays Adobe Animate HTML5 Canvas (CreateJS) content on pixi.js from runtime content files generated at development time, without CreateJS. Trigger on any mention of 'pixi-animate-runtime', 'runtime content', 'Animate コンテンツ', 'Adobe Animate' or 'createjs' in a project that has @tawaship/pixi-animate-runtime installed, or on concepts like loadContentAsync, AnimateContainer, AnimateController, content.create, PIXI.animateRuntime, or the 'npx pixi-animate-runtime' command. If the project uses @tawaship/pixi-animate-container instead (CreateJS at run time, loadAssetAsync), use the pixi-animate-container-guide skill. If the user is working with Pixim.js, use the pixim-animate-runtime-guide skill (it builds on this one).
+---
+
+# @tawaship/pixi-animate-runtime development skill
+
+Supported versions: **`^0.1.0`** (written against `0.1.0`).
+
+First determine the installed version (`node_modules/@tawaship/pixi-animate-runtime/package.json`). If it is outside the supported range, **treat the type definitions in node_modules as authoritative** and follow them wherever they disagree with this skill.
+
+The content is assumed to be published by **Adobe Animate 24.0.15** for HTML5 Canvas, the only version checked: this package depends on the form of the published JavaScript. If the user's content comes from another version of Animate and something does not work, mention this before looking for other causes.
+
+## Dependencies
+
+Read these skills first if they are available, then apply this one:
+
+- A PixiJS v5.3 skill (such as pixijs-guide): the player runs on pixi.js 5.3 (`^5.3.2`)
+
+## Overview
+
+"Animate content" is what Adobe Animate publishes in HTML5 Canvas mode: a JavaScript file (plus images) that runs on CreateJS. This package plays it on pixi.js in two steps:
+
+1. **At development time (Node.js 18+)**, the generator turns the published JavaScript into a **runtime content file** (one per published file). This runs CreateJS once and records every symbol
+2. **In the browser**, the player loads runtime content files and plays them. **CreateJS and the published JavaScript are not loaded**
+
+Consequences to keep in mind:
+
+- **After the content is published again from Animate, the runtime content must be generated again.** The player never reads the published `.js`. When a change made in Animate does not show, check this first
+- Never write `<script>` tags for CreateJS or the published `.js` in a project using this package
+
+## Type definition files
+
+**Before writing code that uses a class, method, or property of this package, check the corresponding type definition file** in the installed package (`node_modules/@tawaship/pixi-animate-runtime/`). That is the single source of truth.
+
+| What | Type definition file |
+|---|---|
+| Everything the player exports | `types/player/index.d.ts` |
+| `loadContentAsync`, `IContentTarget` (the load options) | `types/player/loader.d.ts` |
+| `IContent` (`create`, `lib`, `properties`, `id`), `tick` | `types/player/content.d.ts` |
+| `AnimateContainer`, `AnimateController` | `types/player/animate-container.d.ts` |
+| `MovieClip` (`play`, `stop`, `gotoAndPlay`, `labels`, ...) | `types/player/movieclip.d.ts` |
+| `DisplayObject`, `Container` (the CreateJS-compatible base classes, `pixi`) | `types/player/display.d.ts` |
+| `Shape`, `Sprite`, `Bitmap`, `Text`, `ButtonHelper`, `ColorFilter` | `types/player/objects.d.ts` |
+| The generator (Node): `planGeneration`, `writeGeneration`, `generateFromPublishedFile`, `generate` | `types/generator/generator/index.d.ts` (the plan types in `types/generator/generator/plan.d.ts`) |
+
+## Basic usage
+
+### 1. Generate the runtime content (development time)
+
+```sh
+npx --no-install @tawaship/pixi-animate-runtime assets/animates
+```
+
+Give it the directory Animate published into. It writes `assets/animates/generated/<same name>.js` for every published `.js`, and copies the images each content uses next to it (`generated/images/...`). Copy the `generated/` directory into the application's assets.
+
+- `-o, --out-dir <dir>` writes there instead of `generated/`. `-r, --recursive` also converts the published files in the directories below (not `node_modules` or hidden ones), written below `-o` at the same relative paths, or next to each published file in `generated/`. `-h, --help` shows the usage. A published `.js` file instead of a directory converts only that file
+- It first lists what it would write as a table (where from and where to, then for each published file its composition id shortened to 8 characters, the number of images, and new / replace / not written with the reason). For the whole composition id, read `lib.properties.id` in the published file or the comment at the top of the runtime content file. It writes only after the user answers `y`. `-y, --yes` asks nothing and writes; run from a script, an npm script in CI or anything that is not a terminal, **`-y` is needed** (without it, nothing is written and the command exits with `1`)
+- Nothing is deleted. Leftover files in the output directory are only listed
+- Always write the command as `npx --no-install @tawaship/pixi-animate-runtime` (in npm scripts, `pixi-animate-runtime` alone). A bare `npx pixi-animate-runtime` in a project where the package is not installed downloads and runs an unscoped package of that name from the npm registry, without asking in CI or scripts. `yes=false` in the project's `.npmrc` keeps `npx` from downloading anything
+- From a Node script, `planGeneration(options)` (the same options as the command: `input`, `outDir`, `recursive`, `force`) makes everything and writes nothing, and `writeGeneration(plan)` writes it, so the script can show its own list or questions in between (or remove contents from the plan to write only some)
+- A content using unsupported features (each one listed) is not written, and the command exits with `1`. Report the listed features to the user; do not reach for `--force`
+- On Windows, `tools/pixi-animate-runtime.bat` in the installed package does the same (copy it into the project, drop the published directory on it)
+- The command prints each content's **composition id**, needed below
+
+### 2. Load and play (browser)
+
+```html
+<script src="pixi.js"></script>
+<script src="pixi-animate-runtime.js"></script>
+<script src="assets/animates/generated/game.js"></script><!-- runtime content file -->
+```
+
+```javascript
+const { loadContentAsync, AnimateContainer } = PIXI.animateRuntime;
+
+loadContentAsync({ id: 'COMPOSITION_ID', basepath: 'assets/animates/generated/' })
+  .then((content) => {
+    const container = new AnimateContainer();
+    app.stage.addChild(container);
+    app.ticker.add(container.handleTick, container); // required: nothing plays without it
+
+    container.addCreatejs(content.create('game')); // the symbol the published HTML used as its root
+  });
+```
+
+- Runtime content files must be loaded (script tags, or script elements added at run time) **before** `loadContentAsync` is called. They register under their composition id
+- `id`: the composition id (`lib.properties.id`; printed by the command, and written at the top of the runtime content file). When nothing is registered under it, the error lists what is
+- `basepath`: the directory the runtime content file was written to, ending with `/`; images are loaded relative to it
+- `options.crossOrigin: false` loads images without CORS. `options.handleManifest(manifest)` can change image `src` before loading
+- An array of targets gives an array of contents
+- With a bundler: `import { loadContentAsync, AnimateContainer } from '@tawaship/pixi-animate-runtime'`. Runtime content files are still loaded as scripts
+
+### 3. Creating instances
+
+- `content.create('symbolName')` creates an instance set up the way the published HTML sets up its root. Use it for every instance the application places
+- `new content.lib.symbolName()` is what frame scripts do; it skips that setup
+- `content.properties` holds the published `lib.properties` (`width`, `height`, `fps`, `color`, ...)
+- Symbol names are the library names in Animate (non-ASCII names kept as they are)
+
+### 4. AnimateContainer
+
+- `addCreatejs(instance)` / `addCreatejsAt(instance, index)` put an instance on the container; a movie clip plays from its first frame. `removeCreatejs(instance)` takes it off and it stops
+- Content plays at its published frame rate whatever the display's refresh rate
+- `speed`: playback speed (`1` = published frame rate, `0` stops)
+- `overSpeed` (default `true`): when the display runs slower than the content, one tick may play several frames. `false` plays at most one frame per tick
+- `smooth` (default `true`): frames follow a steady clock, so small variations of the frame time do not make the playing uneven (no frame on one tick, two on the next); it still keeps to the real time. Leave it on unless the user asks for the pixi-animate-container behavior (`false`)
+- To play on a container of another PixiJS framework, use `new AnimateController(container)`; it has the same `addCreatejs`, `handleTick`, `speed`, `overSpeed`, `smooth`
+
+## Objects and their PixiJS nodes
+
+Every instance is a CreateJS-compatible object (what frame scripts see as `this`), shown by a PixiJS node in its `pixi` property. Common values are stored once: `instance.x = 100` and `instance.pixi.x = 100` are the same write, and `instance.pixi` is always current.
+
+Members whose meaning differs keep the CreateJS meaning on the instance and the PixiJS meaning on the node:
+
+| Member | On the instance | On `instance.pixi` |
+|---|---|---|
+| `rotation` | Degrees | Radians (`angle` is degrees) |
+| `skewX` / `skewY` | Degrees, CreateJS skew | `skew` in radians |
+| `mask`, `filters`, `parent`, `children` | CreateJS-compatible objects | PixiJS objects |
+
+- **Do not draw into a shape's `pixi` node** (`clear()`, `lineTo()`, ...): shapes showing the same drawing share one geometry, so the change shows everywhere
+- Named instances placed in Animate (`this.button`, ...) exist at run time but are not in the types (`MovieClip` has no index signature)
+- `addEventListener` / `dispatchEvent` follow CreateJS, so the usual pattern of dispatching an event from a frame script and listening in the application works
+- Frame scripts run as published. They see `this`, `cjs` / `createjs` (the player's compatible classes, not real CreateJS) and `lib`. `exportRoot` and `stage` are undefined; `playSound()` plays nothing
+
+## Current limits (tell the user instead of working around silently)
+
+- Buttons do not react to the pointer and CreateJS mouse events (`click`, `mousedown`, `rollover`, ...) are never called. For input, listen to PixiJS events on `instance.pixi` (`pointertap`, ... with `interactive = true`)
+- Sound is not played
+- The Animate camera ("Advanced Layers") is not supported: delete the camera layer and publish again
+- Dynamic text: lines break as in the published content; vertical position can differ slightly by font
+
+## Coming from pixi-animate-container
+
+| pixi-animate-container | pixi-animate-runtime |
+|---|---|
+| Script tags for CreateJS and the published `.js` | Script tag for the runtime content file only |
+| `PIXI.animate` | `PIXI.animateRuntime` |
+| `loadAssetAsync(targets)` → `lib` | `loadContentAsync(targets)` → content (`content.lib`) |
+| `new lib.game()` | `content.create('game')` |
+| `PIXI.animate.Container` | `AnimateContainer` |
+| `createjsSpeed` / `createjsOverSpeed` | `speed` / `overSpeed` |
+| `CreatejsMovieClip` etc. | `MovieClip` etc. |
+
+Not available: `listenFrameEvents`, `useSound`, CreateJS mouse events.

package/dist-skills/pixim-animate-runtime-guide/SKILL.md

@@ -0,0 +1,112 @@
+---
+name: pixim-animate-runtime-guide
+description: Use this skill whenever the user asks to create, edit, or debug content using @tawaship/pixim-animate-runtime — a plugin that plays Adobe Animate HTML5 Canvas (CreateJS) content in Pixim.js applications from runtime content files generated at development time, without CreateJS. Trigger on any mention of 'pixim-animate-runtime', 'Animate コンテンツ', 'Adobe Animate' or 'createjs' in a Pixim.js project that has @tawaship/pixim-animate-runtime installed, or on concepts like defineAnimateContentsTo, addAnimateContentsTo, $.resources.animateContents, Pixim.animateRuntime, or AnimateContainer in a Pixim.js project. If the project uses @tawaship/pixim-animate-container instead (CreateJS at run time, defineAnimatesTo), use the pixim-animate-container-guide skill.
+---
+
+# @tawaship/pixim-animate-runtime development skill
+
+Supported versions: **`^0.1.0`** (written against `0.1.0`).
+
+First determine the installed version (`node_modules/@tawaship/pixim-animate-runtime/package.json`). If it is outside the supported range, **treat the type definitions in node_modules as authoritative** and follow them wherever they disagree with this skill.
+
+The content is assumed to be published by **Adobe Animate 24.0.15** for HTML5 Canvas, the only version checked: this package depends on the form of the published JavaScript. If the user's content comes from another version of Animate and something does not work, mention this before looking for other causes.
+
+## Dependencies
+
+Read these skills first, then apply this one:
+
+- **pixi-animate-runtime-guide** — this package is the player of `@tawaship/pixi-animate-runtime` with Pixim.js loading and playing. Generating runtime content, creating instances, the objects and their PixiJS nodes, and the current limits are all described there and apply unchanged
+- A Pixim.js v1.15 skill (such as pixim-js-dev) and a PixiJS v5.3 skill, if available
+
+## Overview
+
+This package bundles the player of pixi-animate-runtime (do not load pixi-animate-runtime as well) and adds what a Pixim application needs:
+
+- Contents are **assets of a Pixim content**: defined with `defineAnimateContentsTo`, loaded with the content's other assets, and given as `$.resources.animateContents[name]`
+- `AnimateContainer` is a **Pixim container** that plays the instances put on it through its task, while it is on the display tree of a running application
+
+As with pixi-animate-runtime, **runtime content files are generated at development time** (`npx --no-install @tawaship/pixi-animate-runtime <published directory>`) and must be generated again after publishing again from Animate. CreateJS and the published `.js` are never loaded.
+
+## Type definition files
+
+**Before writing code that uses a class, method, or property of this package, check the corresponding type definition file** in the installed package (`node_modules/@tawaship/pixim-animate-runtime/types/`). Everything of pixi-animate-runtime is re-exported; its types are in `node_modules/@tawaship/pixi-animate-runtime/types/player/` (see pixi-animate-runtime-guide).
+
+| What | Type definition file |
+|---|---|
+| Everything exported | `types/index.d.ts` |
+| `defineAnimateContentsTo`, `addAnimateContentsTo`, `ANIMATE_CONTENTS` | `types/AnimateContentManifest.d.ts` |
+| The target of each content (`id`, `basepath`, `filepath`, `options`) | `types/AnimateContentLoader.d.ts` |
+| `AnimateContainer` (Pixim) | `types/AnimateContainer.d.ts` |
+
+## Basic usage
+
+### 1. Loading the scripts
+
+```html
+<script src="pixi.js"></script>
+<script src="Pixim.js"></script>
+<script src="pixim-animate-runtime.js"></script>
+```
+
+In a browser setup the module is `Pixim.animateRuntime`. With a bundler: `import { defineAnimateContentsTo, AnimateContainer } from '@tawaship/pixim-animate-runtime'`.
+
+### 2. Defining contents and playing them
+
+```javascript
+const { defineAnimateContentsTo, AnimateContainer } = Pixim.animateRuntime;
+
+const Game = Pixim.Content.create();
+
+defineAnimateContentsTo(Game, {
+  title: { id: 'COMPOSITION_ID', basepath: 'assets/animates/', filepath: 'title.js' }
+});
+
+class Root extends Pixim.Container {
+  constructor($) {
+    super();
+    const content = $.resources.animateContents.title;
+    const container = new AnimateContainer();
+    this.addChild(container);
+    container.addCreatejs(content.create('title')); // the symbol the published HTML used as its root
+  }
+}
+
+Game.defineLibraries({ root: Root });
+```
+
+- `id`: the composition id (printed by `npx --no-install @tawaship/pixi-animate-runtime`, and written at the top of the runtime content file)
+- `basepath`: the directory of the runtime content file and its images, relative to the Pixim content's `basepath` option
+- `filepath`: the runtime content file, relative to `basepath`. Without it, the file has to be loaded already (by a script tag)
+- `options`: as pixi-animate-runtime's `loadContentAsync` (`crossOrigin`, `handleManifest`)
+- `defineAnimateContentsTo(Game, targets, { unrequired: true })` gives `null` for a content that failed to load instead of failing the whole Pixim content
+- `addAnimateContentsTo(game, targets)` adds contents to one instance of a Pixim content
+- `$.resources.animateContents.title` is the content as `loadContentAsync` gives it: `id`, `lib`, `properties`, `create(id)`
+
+**No ticker wiring is needed**: unlike pixi-animate-runtime's container, the Pixim `AnimateContainer` plays through its own task while it is on the display tree of a running application.
+
+### 3. Options of the Pixim content
+
+The Pixim content's own options apply to runtime content files and images as to its other assets:
+
+- `version` adds `_fv=<version>` to the URLs. `typeOptions.animateContents.fileVersion` / `assetVersion` set it for the files / the images separately
+- `xhr` fetches the runtime content files and the images with its request options
+
+### 4. AnimateContainer
+
+- `addCreatejs(instance)` / `addCreatejsAt(instance, index)` / `removeCreatejs(instance)`; a movie clip put on again starts from its first frame
+- `speed` (`1` = published frame rate, `0` stops), `overSpeed` (default `true`; `false` plays at most one frame per application frame), `smooth` (default `true`; even playing when the frame time varies a little, as in pixi-animate-runtime-guide)
+- `taskEnabled = false` stops playing. The container's `task` is free for your own use: clearing it does not stop playing
+
+## Coming from pixim-animate-container
+
+| pixim-animate-container | pixim-animate-runtime |
+|---|---|
+| Script tag for CreateJS | None |
+| `Pixim.animate` | `Pixim.animateRuntime` |
+| `defineAnimatesTo(Game, {...})`, `filepath` = published `.js` | `defineAnimateContentsTo(Game, {...})`, `filepath` = runtime content file |
+| `addAnimatesTo` | `addAnimateContentsTo` |
+| `$.resources.animates.name` (`lib`) → `new ...game()` | `$.resources.animateContents.name` (content) → `.create('game')` |
+| `Pixim.animate.Container` | `AnimateContainer` |
+| `createjsSpeed` / `createjsOverSpeed` | `speed` / `overSpeed` |
+
+Not available: `replaceInstance()`, `replaceTexture()`, and what pixi-animate-runtime does not have (`listenFrameEvents`, `useSound`, CreateJS mouse events).

package/package.json

@@ -1,6 +1,55 @@
 {
   "name": "@tawaship/pixim-animate-runtime",
-  "version": "0.0.0-stage",
-  "stub": true,
-  "description": "Temporary package placeholder for staged publishing"
-}
+  "version": "0.1.0",
+  "description": "Plays Adobe Animate HTML5 Canvas content in Pixim.js: loads runtime content generated by @tawaship/pixi-animate-runtime as a Pixim content asset.",
+  "main": "dist/pixim-animate-runtime.cjs.js",
+  "module": "dist/pixim-animate-runtime.esm.js",
+  "browser": "dist/pixim-animate-runtime.js",
+  "types": "types/index.d.ts",
+  "files": [
+    "dist",
+    "types",
+    "dist-skills"
+  ],
+  "scripts": {
+    "rollup": "rollup -c --bundleConfigAsCjs",
+    "d": "tsc -p tsconfig.json --emitDeclarationOnly --declaration --outDir ./types",
+    "build": "npm run rollup -- --environment PROD && npm run d && echo done.",
+    "docs": "typedoc",
+    "prepublishOnly": "node scripts/check-publish.js"
+  },
+  "keywords": [
+    "pixi.js",
+    "pixim.js",
+    "adobe-animate",
+    "createjs"
+  ],
+  "author": "tawaship",
+  "license": "MIT",
+  "repository": {
+    "type": "git",
+    "url": "git+https://github.com/tawaship/Pixim-animate-runtime.git"
+  },
+  "bugs": {
+    "url": "https://github.com/tawaship/Pixim-animate-runtime/issues"
+  },
+  "homepage": "https://tawaship.github.io/Pixim-animate-runtime/",
+  "peerDependencies": {
+    "@tawaship/pixim.js": "^1.15.2",
+    "pixi.js": "^5.3.2"
+  },
+  "dependencies": {
+    "@tawaship/pixi-animate-runtime": "^0.1.0"
+  },
+  "devDependencies": {
+    "@rollup/plugin-buble": "^1.0.3",
+    "@rollup/plugin-typescript": "^12.3.1",
+    "@tawaship/pixim.js": "1.15.2",
+    "del": "^8.0.1",
+    "pixi.js": "5.3.9",
+    "rollup": "^4.65.0",
+    "tslib": "^2.8.1",
+    "typedoc": "^0.28.20",
+    "typescript": "^6.0.3"
+  }
+}

package/types/AnimateContainer.d.ts

@@ -0,0 +1,34 @@
+import { Container, ITickerData } from '@tawaship/pixim.js';
+import { DisplayObject } from '@tawaship/pixi-animate-runtime';
+/**
+ * A Pixim container that plays the content roots put on it at their
+ * content's frame rate (the rate the content was published with), while it is
+ * on the display tree of a running Pixim application.
+ *
+ * Each frame of the application plays `delta x speed x fps / 60` frames of every
+ * root (delta being the application ticker's), one frame being createjs's tick
+ * phase followed by its resolve phase; the first frame after a root is put on
+ * only settles it on its first frame. Playing stops while `taskEnabled` is
+ * false. The container's own `task` is free for the application: what it holds
+ * does not change the playing.
+ */
+export declare class AnimateContainer extends Container {
+    private readonly _controller;
+    constructor();
+    /** Playback speed (1 is the content's own frame rate) */
+    get speed(): number;
+    set speed(value: number);
+    /** Whether one frame of the application may play more than one frame of a root (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);
+    updateTask(e: ITickerData): void;
+    /** Plays the roots by hand, as one frame of the application with this delta does */
+    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/AnimateContentLoader.d.ts

@@ -0,0 +1,35 @@
+import { ILoaderOption, LoaderBase, LoaderResource, TLoaderResourceVersion } from '@tawaship/pixim.js';
+import { IContent, IContentTarget } from '@tawaship/pixi-animate-runtime';
+/** A content to load: what loadContentAsync takes, and the runtime content file to load first */
+export interface IAnimateContentLoaderTarget extends IContentTarget {
+    /**
+     * The runtime content file, relative to `basepath`. Loaded (as a script) before
+     * the content when given; otherwise it has to be loaded already.
+     */
+    filepath?: string;
+}
+export interface IAnimateContentLoaderOption extends ILoaderOption {
+    /** The version added to the runtime content file's URL (`version` when omitted) */
+    fileVersion?: TLoaderResourceVersion;
+    /** The version added to the image URLs (`version` when omitted) */
+    assetVersion?: TLoaderResourceVersion;
+}
+export declare class AnimateContentLoaderResource extends LoaderResource<IContent | null> {
+    destroy(): void;
+}
+/**
+ * Loads a content as a Pixim asset: its runtime content file (when a filepath
+ * is given), then the content with loadContentAsync, the base path being the
+ * Pixim content's and the target's together.
+ *
+ * With the Pixim content's `xhr` option, the images are fetched (with its
+ * request options) into blob: URLs first, after the target's own
+ * handleManifest; the blob: URLs are released once the content is loaded.
+ */
+export declare class AnimateContentLoader extends LoaderBase<IAnimateContentLoaderTarget, IContent | null, AnimateContentLoaderResource> {
+    protected _loadAsync(target: IAnimateContentLoaderTarget, options?: IAnimateContentLoaderOption): Promise<AnimateContentLoaderResource>;
+    private _loadFileAsync;
+    private _loadContentAsync;
+    /** The images fetched into blob: URLs, which then stand for their files */
+    private _fetchImagesAsync;
+}

package/types/AnimateContentManifest.d.ts

@@ -0,0 +1,17 @@
+import { Content, IManifestOption, ManifestBase } from '@tawaship/pixim.js';
+import { IContent } from '@tawaship/pixi-animate-runtime';
+import { AnimateContentLoader, AnimateContentLoaderResource, IAnimateContentLoaderTarget } from './AnimateContentLoader';
+/** The key of the contents in a Pixim content's resources: `$.resources.animateContents` */
+export declare const ANIMATE_CONTENTS = "animateContents";
+export declare class AnimateContentManifest extends ManifestBase<IAnimateContentLoaderTarget, IContent | null, AnimateContentLoaderResource> {
+    protected _createLoader(): AnimateContentLoader;
+}
+/**
+ * Defines contents for a Pixim content class: each is loaded with the class's
+ * other assets and given as `$.resources.animateContents[name]`.
+ */
+export declare function defineAnimateContentsTo(PiximContent: typeof Content, targets: Record<string, IAnimateContentLoaderTarget>, options?: IManifestOption): typeof Content;
+/**
+ * Adds contents to a Pixim content instance (loaded with its other assets).
+ */
+export declare function addAnimateContentsTo(content: Content, targets: Record<string, IAnimateContentLoaderTarget>, options?: IManifestOption): Content;

package/types/index.d.ts

@@ -0,0 +1,5 @@
+export * from '@tawaship/pixi-animate-runtime';
+export { AnimateContainer } from './AnimateContainer';
+export { AnimateContentLoader, AnimateContentLoaderResource } from './AnimateContentLoader';
+export type { IAnimateContentLoaderTarget, IAnimateContentLoaderOption } from './AnimateContentLoader';
+export { AnimateContentManifest, ANIMATE_CONTENTS, defineAnimateContentsTo, addAnimateContentsTo } from './AnimateContentManifest';