@akashic/headless-driver 1.11.37 → 2.0.1

package/lib/runner/v3/index.d.ts

@@ -0,0 +1,5 @@
+export * from "./RunnerV3";
+export * from "./platform/PlatformV3";
+export { akashicEngine as RunnerV3_g } from "./engineFiles";
+export { gameDriver as RunnerV3_gdr } from "./engineFiles";
+export { pdi as RunnerV3_pdi } from "./engineFiles";

package/lib/runner/v3/index.js

@@ -0,0 +1,25 @@
+"use strict";
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __exportStar = (this && this.__exportStar) || function(m, exports) {
+    for (var p in m) if (p !== "default" && !Object.prototype.hasOwnProperty.call(exports, p)) __createBinding(exports, m, p);
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.RunnerV3_pdi = exports.RunnerV3_gdr = exports.RunnerV3_g = void 0;
+__exportStar(require("./RunnerV3"), exports);
+__exportStar(require("./platform/PlatformV3"), exports);
+var engineFiles_1 = require("./engineFiles");
+Object.defineProperty(exports, "RunnerV3_g", { enumerable: true, get: function () { return engineFiles_1.akashicEngine; } });
+var engineFiles_2 = require("./engineFiles");
+Object.defineProperty(exports, "RunnerV3_gdr", { enumerable: true, get: function () { return engineFiles_2.gameDriver; } });
+var engineFiles_3 = require("./engineFiles");
+Object.defineProperty(exports, "RunnerV3_pdi", { enumerable: true, get: function () { return engineFiles_3.pdi; } });

package/lib/runner/v3/platform/NodeCanvasResourceFactory.d.ts

@@ -0,0 +1,22 @@
+import type { akashicEngine as g } from "../engineFiles";
+export interface NodeCanvasResourceFactoryParameters {
+    loadFileHandler: (url: string, callback: (err: Error | null, data?: string) => void) => void;
+    errorHandler: (err: Error) => void;
+}
+/**
+ * node-canvas への描画出力機能を持つ ResourceFactory の実装。
+ * 音声再生には未対応。
+ */
+export declare class NodeCanvasResourceFactory implements g.ResourceFactory {
+    private loadFileHandler;
+    private errorHandler;
+    constructor({ loadFileHandler, errorHandler }: NodeCanvasResourceFactoryParameters);
+    createImageAsset(id: string, assetPath: string, width: number, height: number): g.ImageAsset;
+    createVideoAsset(id: string, assetPath: string, width: number, height: number, system: g.VideoSystem, loop: boolean, useRealSize: boolean): g.VideoAsset;
+    createAudioAsset(id: string, assetPath: string, duration: number, system: g.AudioSystem, loop: boolean, hint: g.AudioAssetHint): g.AudioAsset;
+    createAudioPlayer(system: g.AudioSystem): g.AudioPlayer;
+    createTextAsset(id: string, assetPath: string): g.TextAsset;
+    createScriptAsset(id: string, assetPath: string): g.ScriptAsset;
+    createSurface(width: number, height: number): g.Surface;
+    createGlyphFactory(fontFamily: string | string[], fontSize: number, baselineHeight?: number, fontColor?: string, strokeWidth?: number, strokeColor?: string, strokeOnly?: boolean, fontWeight?: g.FontWeightString): g.GlyphFactory;
+}

package/lib/runner/v3/platform/NodeCanvasResourceFactory.js

@@ -0,0 +1,57 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.NodeCanvasResourceFactory = void 0;
+const canvas_1 = require("canvas");
+const NodeScriptAsset_1 = require("./assets/NodeScriptAsset");
+const NodeTextAsset_1 = require("./assets/NodeTextAsset");
+const NullAudioAsset_1 = require("./audios/NullAudioAsset");
+const NullAudioPlayer_1 = require("./audios/NullAudioPlayer");
+const NodeCanvasGlyphFactory_1 = require("./graphics/canvas/NodeCanvasGlyphFactory");
+const NodeCanvasImageAsset_1 = require("./graphics/canvas/NodeCanvasImageAsset");
+const NodeCanvasSurface_1 = require("./graphics/canvas/NodeCanvasSurface");
+const NullVideoAsset_1 = require("./videos/NullVideoAsset");
+/**
+ * node-canvas への描画出力機能を持つ ResourceFactory の実装。
+ * 音声再生には未対応。
+ */
+class NodeCanvasResourceFactory {
+    constructor({ loadFileHandler, errorHandler }) {
+        this.loadFileHandler = loadFileHandler;
+        this.errorHandler = errorHandler;
+    }
+    createImageAsset(id, assetPath, width, height) {
+        return new NodeCanvasImageAsset_1.NodeCanvasImageAsset(id, assetPath, width, height);
+    }
+    createVideoAsset(id, assetPath, width, height, system, loop, useRealSize) {
+        return new NullVideoAsset_1.NullVideoAsset(id, assetPath, width, height, system, loop, useRealSize);
+    }
+    createAudioAsset(id, assetPath, duration, system, loop, hint) {
+        return new NullAudioAsset_1.NullAudioAsset(id, assetPath, duration, system, loop, hint);
+    }
+    createAudioPlayer(system) {
+        return new NullAudioPlayer_1.NullAudioPlayer(system);
+    }
+    createTextAsset(id, assetPath) {
+        return new NodeTextAsset_1.NodeTextAsset({
+            id,
+            path: assetPath,
+            loadFileHandler: this.loadFileHandler
+        });
+    }
+    createScriptAsset(id, assetPath) {
+        return new NodeScriptAsset_1.NodeScriptAsset({
+            id,
+            path: assetPath,
+            errorHandler: this.errorHandler,
+            loadFileHandler: this.loadFileHandler
+        });
+    }
+    createSurface(width, height) {
+        const canvas = new canvas_1.Canvas(width, height);
+        return new NodeCanvasSurface_1.NodeCanvasSurface(canvas);
+    }
+    createGlyphFactory(fontFamily, fontSize, baselineHeight, fontColor, strokeWidth, strokeColor, strokeOnly, fontWeight) {
+        return new NodeCanvasGlyphFactory_1.NodeCanvasGlyphFactory(fontFamily, fontSize, baselineHeight, fontColor, strokeWidth, strokeColor, strokeOnly, fontWeight);
+    }
+}
+exports.NodeCanvasResourceFactory = NodeCanvasResourceFactory;

package/lib/runner/v3/platform/NullResourceFactory.d.ts

@@ -0,0 +1,21 @@
+import type { akashicEngine as g } from "../engineFiles";
+export interface NullResourceFactoryParameters {
+    loadFileHandler: (url: string, callback: (err: Error | null, data?: string) => void) => void;
+    errorHandler: (err: Error) => void;
+}
+/**
+ * 描画出力や音声再生機能を持たない最小限の ResourceFactory の実装。
+ */
+export declare class NullResourceFactory implements g.ResourceFactory {
+    private loadFileHandler;
+    private errorHandler;
+    constructor({ loadFileHandler, errorHandler }: NullResourceFactoryParameters);
+    createImageAsset(id: string, assetPath: string, width: number, height: number): g.ImageAsset;
+    createVideoAsset(id: string, assetPath: string, width: number, height: number, system: g.VideoSystem, loop: boolean, useRealSize: boolean): g.VideoAsset;
+    createAudioAsset(id: string, assetPath: string, duration: number, system: g.AudioSystem, loop: boolean, hint: g.AudioAssetHint): g.AudioAsset;
+    createAudioPlayer(system: g.AudioSystem): g.AudioPlayer;
+    createTextAsset(id: string, assetPath: string): g.TextAsset;
+    createScriptAsset(id: string, assetPath: string): g.ScriptAsset;
+    createSurface(width: number, height: number): g.Surface;
+    createGlyphFactory(fontFamily: string | string[], fontSize: number, baselineHeight?: number, fontColor?: string, strokeWidth?: number, strokeColor?: string, strokeOnly?: boolean, fontWeight?: g.FontWeightString): g.GlyphFactory;
+}

package/lib/runner/v3/platform/NullResourceFactory.js

@@ -0,0 +1,54 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.NullResourceFactory = void 0;
+const NodeScriptAsset_1 = require("./assets/NodeScriptAsset");
+const NodeTextAsset_1 = require("./assets/NodeTextAsset");
+const NullAudioAsset_1 = require("./audios/NullAudioAsset");
+const NullAudioPlayer_1 = require("./audios/NullAudioPlayer");
+const NullGlyphFactory_1 = require("./graphics/null/NullGlyphFactory");
+const NullImageAsset_1 = require("./graphics/null/NullImageAsset");
+const NullSurface_1 = require("./graphics/null/NullSurface");
+const NullVideoAsset_1 = require("./videos/NullVideoAsset");
+/**
+ * 描画出力や音声再生機能を持たない最小限の ResourceFactory の実装。
+ */
+class NullResourceFactory {
+    constructor({ loadFileHandler, errorHandler }) {
+        this.loadFileHandler = loadFileHandler;
+        this.errorHandler = errorHandler;
+    }
+    createImageAsset(id, assetPath, width, height) {
+        return new NullImageAsset_1.NullImageAsset(id, assetPath, width, height);
+    }
+    createVideoAsset(id, assetPath, width, height, system, loop, useRealSize) {
+        return new NullVideoAsset_1.NullVideoAsset(id, assetPath, width, height, system, loop, useRealSize);
+    }
+    createAudioAsset(id, assetPath, duration, system, loop, hint) {
+        return new NullAudioAsset_1.NullAudioAsset(id, assetPath, duration, system, loop, hint);
+    }
+    createAudioPlayer(system) {
+        return new NullAudioPlayer_1.NullAudioPlayer(system);
+    }
+    createTextAsset(id, assetPath) {
+        return new NodeTextAsset_1.NodeTextAsset({
+            id,
+            path: assetPath,
+            loadFileHandler: this.loadFileHandler
+        });
+    }
+    createScriptAsset(id, assetPath) {
+        return new NodeScriptAsset_1.NodeScriptAsset({
+            id,
+            path: assetPath,
+            errorHandler: this.errorHandler,
+            loadFileHandler: this.loadFileHandler
+        });
+    }
+    createSurface(width, height) {
+        return new NullSurface_1.NullSurface(width, height);
+    }
+    createGlyphFactory(fontFamily, fontSize, baselineHeight, fontColor, strokeWidth, strokeColor, strokeOnly, fontWeight) {
+        return new NullGlyphFactory_1.NullGlyphFactory(fontFamily, fontSize, baselineHeight, fontColor, strokeWidth, strokeColor, strokeOnly, fontWeight);
+    }
+}
+exports.NullResourceFactory = NullResourceFactory;

package/lib/runner/v3/platform/PlatformV3.d.ts

@@ -0,0 +1,23 @@
+import { Looper } from "../../../Looper";
+import type { PlatformParameters } from "../../Platform";
+import { Platform } from "../../Platform";
+import type { akashicEngine as g, pdi } from "../engineFiles";
+export declare class PlatformV3 extends Platform implements pdi.Platform {
+    private resFac;
+    private rendererReq;
+    private primarySurface;
+    private eventHandler;
+    private loopers;
+    private isLooperPaused;
+    constructor(param: PlatformParameters);
+    getResourceFactory(): g.ResourceFactory;
+    setRendererRequirement(requirement: pdi.RendererRequirement): void;
+    setPlatformEventHandler(handler: pdi.PlatformEventHandler): void;
+    getPrimarySurface(): g.Surface;
+    createLooper(fun: (deltaTime: number) => number): Looper;
+    advanceLoopers(ms: number): void;
+    pauseLoopers(): void;
+    resumeLoopers(): void;
+    stepLoopers(): void;
+    firePointEvent(event: pdi.PlatformPointEvent): void;
+}

package/lib/runner/v3/platform/PlatformV3.js

@@ -0,0 +1,94 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.PlatformV3 = void 0;
+const Looper_1 = require("../../../Looper");
+const Platform_1 = require("../../Platform");
+const NullSurface_1 = require("./graphics/null/NullSurface");
+class PlatformV3 extends Platform_1.Platform {
+    constructor(param) {
+        super(param);
+        this.rendererReq = null;
+        this.primarySurface = null;
+        this.eventHandler = null;
+        this.loopers = [];
+        this.isLooperPaused = false;
+        // NOTE: このファイルの require() 時点で ResourceFactory 側の依存モジュールを読み込ませないよう、動的に require() する。
+        // (このモジュールの利用元である headless-driver が NodeVM 上で起動する仕様上の制限のための苦肉の策)
+        /* eslint-disable @typescript-eslint/naming-convention, @typescript-eslint/no-var-requires */
+        const ResourceFactory = this.renderingMode === "canvas" && this.trusted
+            ? require("./NodeCanvasResourceFactory").NodeCanvasResourceFactory
+            : require("./NullResourceFactory").NullResourceFactory;
+        /* eslint-enable */
+        this.resFac = new ResourceFactory({
+            errorHandler: (e) => this.errorHandler(e),
+            loadFileHandler: param.loadFileHandler
+        });
+    }
+    getResourceFactory() {
+        return this.resFac;
+    }
+    setRendererRequirement(requirement) {
+        this.rendererReq = requirement;
+        if (this.renderingMode === "canvas") {
+            if (this.trusted) {
+                /* eslint-disable @typescript-eslint/naming-convention, @typescript-eslint/no-var-requires */
+                const Canvas = require("canvas").Canvas;
+                const NodeCanvasSurface = require("./graphics/canvas/NodeCanvasSurface").NodeCanvasSurface;
+                /* eslint-enable */
+                const canvas = new Canvas(this.rendererReq.primarySurfaceWidth, this.rendererReq.primarySurfaceHeight);
+                this.primarySurface = new NodeCanvasSurface(canvas);
+            }
+            else {
+                throw Error("PlatformV3#setRendererRequirement(): Must given trusted === `true` if set renderingMode === 'canvas'");
+            }
+        }
+        else {
+            this.primarySurface = new NullSurface_1.NullSurface(this.rendererReq.primarySurfaceWidth, this.rendererReq.primarySurfaceHeight);
+        }
+    }
+    setPlatformEventHandler(handler) {
+        this.eventHandler = handler;
+    }
+    getPrimarySurface() {
+        if (this.primarySurface == null) {
+            throw new Error("PlatformV3#getPrimarySurface(): Primary surface has not been initialized yet");
+        }
+        return this.primarySurface;
+    }
+    createLooper(fun) {
+        const looper = new Looper_1.Looper(fun, (e) => this.errorHandler(e));
+        if (this.isLooperPaused) {
+            looper.debugStop();
+        }
+        this.loopers.push(looper);
+        return looper;
+    }
+    advanceLoopers(ms) {
+        for (let i = 0; i < this.loopers.length; i++) {
+            this.loopers[i].debugStep(ms);
+        }
+    }
+    pauseLoopers() {
+        this.isLooperPaused = true;
+        for (let i = 0; i < this.loopers.length; i++) {
+            this.loopers[i].debugStop();
+        }
+    }
+    resumeLoopers() {
+        this.isLooperPaused = false;
+        for (let i = 0; i < this.loopers.length; i++) {
+            this.loopers[i].debugStart();
+        }
+    }
+    stepLoopers() {
+        for (let i = 0; i < this.loopers.length; i++) {
+            // v3 のみ対応。game-driver 側の実装により NaN を渡すと次のフレームまで進む。
+            this.loopers[i].debugStep(NaN);
+        }
+    }
+    firePointEvent(event) {
+        var _a;
+        (_a = this.eventHandler) === null || _a === void 0 ? void 0 : _a.onPointEvent(event);
+    }
+}
+exports.PlatformV3 = PlatformV3;

package/lib/runner/v3/platform/assets/Asset.d.ts

@@ -0,0 +1,14 @@
+import { akashicEngine as g } from "../../engineFiles";
+export declare abstract class Asset implements g.Asset {
+    abstract type: string;
+    id: string;
+    path: string;
+    originalPath: string;
+    onDestroyed: g.Trigger<g.Asset>;
+    constructor(id: string, path: string);
+    destroy(): void;
+    destroyed(): boolean;
+    inUse(): boolean;
+    abstract _load(loader: g.AssetLoadHandler): void;
+    _assetPathFilter(path: string): string;
+}

package/lib/runner/v3/platform/assets/Asset.js

@@ -0,0 +1,30 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.Asset = void 0;
+const engineFiles_1 = require("../../engineFiles");
+class Asset {
+    constructor(id, path) {
+        this.id = id;
+        this.originalPath = path;
+        this.path = this._assetPathFilter(path);
+        this.onDestroyed = new engineFiles_1.akashicEngine.Trigger();
+    }
+    destroy() {
+        this.onDestroyed.fire(this);
+        this.id = undefined;
+        this.originalPath = undefined;
+        this.path = undefined;
+        this.onDestroyed.destroy();
+        this.onDestroyed = undefined;
+    }
+    destroyed() {
+        return this.id === undefined;
+    }
+    inUse() {
+        return false;
+    }
+    _assetPathFilter(path) {
+        return path;
+    }
+}
+exports.Asset = Asset;

package/lib/runner/v3/platform/assets/NodeScriptAsset.d.ts

@@ -0,0 +1,19 @@
+import type { akashicEngine as g } from "../../engineFiles";
+import { Asset } from "./Asset";
+export interface NodeScriptAssetParameters {
+    id: string;
+    path: string;
+    errorHandler: (err: any) => void;
+    loadFileHandler: (url: string, callback: (err: Error | null, data?: string) => void) => void;
+}
+export declare class NodeScriptAsset extends Asset implements g.ScriptAsset {
+    static PRE_SCRIPT: string;
+    static POST_SCRIPT: string;
+    type: "script";
+    script: string;
+    private errorHandler;
+    private loadFileHandler;
+    constructor(param: NodeScriptAssetParameters);
+    _load(loader: g.AssetLoadHandler): void;
+    execute(execEnv: g.ScriptAssetRuntimeValue): any;
+}

package/lib/runner/v3/platform/assets/NodeScriptAsset.js

@@ -0,0 +1,48 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.NodeScriptAsset = void 0;
+const Asset_1 = require("./Asset");
+class NodeScriptAsset extends Asset_1.Asset {
+    constructor(param) {
+        super(param.id, param.path);
+        this.type = "script";
+        this.script = "";
+        this.errorHandler = param.errorHandler;
+        this.loadFileHandler = param.loadFileHandler;
+    }
+    _load(loader) {
+        this.loadFileHandler(this.path, (err, text) => {
+            if (err) {
+                loader._onAssetError(this, {
+                    name: "AssetLoadError",
+                    message: err.message,
+                    retriable: false
+                });
+            }
+            else if (text == null) {
+                loader._onAssetError(this, {
+                    name: "AssetLoadError",
+                    message: "NoteScriptAsset#_load(): No data received",
+                    retriable: false
+                });
+            }
+            else {
+                this.script = text;
+                loader._onAssetLoad(this);
+            }
+        });
+    }
+    execute(execEnv) {
+        const func = new Function("g", NodeScriptAsset.PRE_SCRIPT + this.script + NodeScriptAsset.POST_SCRIPT);
+        try {
+            func(execEnv);
+        }
+        catch (e) {
+            this.errorHandler(e);
+        }
+        return execEnv.module.exports;
+    }
+}
+exports.NodeScriptAsset = NodeScriptAsset;
+NodeScriptAsset.PRE_SCRIPT = "(function(exports, require, module, __filename, __dirname) {\n";
+NodeScriptAsset.POST_SCRIPT = "\n})(g.module.exports, g.module.require, g.module, g.filename, g.dirname);";

package/lib/runner/v3/platform/assets/NodeTextAsset.d.ts

@@ -0,0 +1,14 @@
+import type { akashicEngine as g } from "../../engineFiles";
+import { Asset } from "./Asset";
+export interface NodeTextAssetParameters {
+    id: string;
+    path: string;
+    loadFileHandler: (url: string, callback: (err: Error | null, data?: string) => void) => void;
+}
+export declare class NodeTextAsset extends Asset implements g.TextAsset {
+    type: "text";
+    data: string;
+    private loadFileHandler;
+    constructor(param: NodeTextAssetParameters);
+    _load(loader: g.AssetLoadHandler): void;
+}

package/lib/runner/v3/platform/assets/NodeTextAsset.js

@@ -0,0 +1,35 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.NodeTextAsset = void 0;
+const Asset_1 = require("./Asset");
+class NodeTextAsset extends Asset_1.Asset {
+    constructor(param) {
+        super(param.id, param.path);
+        this.type = "text";
+        this.data = "";
+        this.loadFileHandler = param.loadFileHandler;
+    }
+    _load(loader) {
+        this.loadFileHandler(this.path, (err, text) => {
+            if (err) {
+                loader._onAssetError(this, {
+                    name: "AssetLoadError",
+                    message: err.message,
+                    retriable: false
+                });
+            }
+            else if (text == null) {
+                loader._onAssetError(this, {
+                    name: "AssetLoadError",
+                    message: "NodeTextAsset#_load(): No data received",
+                    retriable: false
+                });
+            }
+            else {
+                this.data = text;
+                loader._onAssetLoad(this);
+            }
+        });
+    }
+}
+exports.NodeTextAsset = NodeTextAsset;

package/lib/runner/v3/platform/audios/NullAudioAsset.d.ts

@@ -0,0 +1,15 @@
+import type { akashicEngine as g } from "../../engineFiles";
+import { Asset } from "../assets/Asset";
+export declare class NullAudioAsset extends Asset implements g.AudioAsset {
+    type: "audio";
+    data: any;
+    duration: number;
+    loop: boolean;
+    hint: g.AudioAssetHint;
+    _system: g.AudioSystem;
+    constructor(id: string, assetPath: string, duration: number, system: g.AudioSystem, loop: boolean, hint: g.AudioAssetHint);
+    _load(loader: g.AssetLoadHandler): void;
+    play(): g.AudioPlayer;
+    stop(): void;
+    inUse(): boolean;
+}

package/lib/runner/v3/platform/audios/NullAudioAsset.js

@@ -0,0 +1,28 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.NullAudioAsset = void 0;
+const Asset_1 = require("../assets/Asset");
+class NullAudioAsset extends Asset_1.Asset {
+    constructor(id, assetPath, duration, system, loop, hint) {
+        super(id, assetPath);
+        this.type = "audio";
+        this.duration = duration;
+        this.loop = loop;
+        this.hint = hint;
+        this._system = system;
+        this.data = undefined;
+    }
+    _load(loader) {
+        loader._onAssetLoad(this);
+    }
+    play() {
+        return this._system.createPlayer();
+    }
+    stop() {
+        //
+    }
+    inUse() {
+        return this._system.findPlayers(this).length > 0;
+    }
+}
+exports.NullAudioAsset = NullAudioAsset;

package/lib/runner/v3/platform/audios/NullAudioPlayer.d.ts

@@ -0,0 +1,17 @@
+import { akashicEngine as g } from "../../engineFiles";
+export declare class NullAudioPlayer implements g.AudioPlayer {
+    currentAudio: g.AudioAsset | undefined;
+    onPlay: g.Trigger<g.AudioPlayerEvent>;
+    onStop: g.Trigger<g.AudioPlayerEvent>;
+    played: g.Trigger<g.AudioPlayerEvent>;
+    stopped: g.Trigger<g.AudioPlayerEvent>;
+    volume: number;
+    _muted: boolean;
+    constructor(system: g.AudioSystem);
+    play(audio: g.AudioAsset): void;
+    stop(): void;
+    canHandleStopped(): boolean;
+    changeVolume(volume: number): void;
+    _changeMuted(muted: boolean): void;
+    _notifyVolumeChanged(): void;
+}

package/lib/runner/v3/platform/audios/NullAudioPlayer.js

@@ -0,0 +1,34 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.NullAudioPlayer = void 0;
+const engineFiles_1 = require("../../engineFiles");
+class NullAudioPlayer {
+    constructor(system) {
+        this.onPlay = new engineFiles_1.akashicEngine.Trigger();
+        this.onStop = new engineFiles_1.akashicEngine.Trigger();
+        this.played = this.onPlay;
+        this.stopped = this.onStop;
+        this.currentAudio = undefined;
+        this.volume = system.volume;
+        this._muted = system._muted;
+    }
+    play(audio) {
+        this.currentAudio = audio;
+    }
+    stop() {
+        //
+    }
+    canHandleStopped() {
+        return true;
+    }
+    changeVolume(volume) {
+        this.volume = volume;
+    }
+    _changeMuted(muted) {
+        this._muted = muted;
+    }
+    _notifyVolumeChanged() {
+        //
+    }
+}
+exports.NullAudioPlayer = NullAudioPlayer;

package/lib/runner/v3/platform/graphics/canvas/CompositeOperationConverter.d.ts

@@ -0,0 +1,6 @@
+import type { akashicEngine as g } from "../../../engineFiles";
+export declare type CompositeOperation = "source-atop" | "lighter" | "copy" | "source-in" | "source-out" | "destination-atop" | "destination-in" | "destination-out" | "destination-over" | "xor" | "source-over";
+export declare class CompositeOperationConverter {
+    static toEngine(operation: CompositeOperation): g.CompositeOperationString;
+    static toContext2D(operation: g.CompositeOperationString): CompositeOperation;
+}

package/lib/runner/v3/platform/graphics/canvas/CompositeOperationConverter.js

@@ -0,0 +1,78 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.CompositeOperationConverter = void 0;
+class CompositeOperationConverter {
+    static toEngine(operation) {
+        if (operation === "source-over") {
+            return "source-over";
+        }
+        else if (operation === "source-atop") {
+            return "source-atop";
+        }
+        else if (operation === "lighter") {
+            return "lighter";
+        }
+        else if (operation === "copy") {
+            return "copy";
+        }
+        else if (operation === "destination-out") {
+            return "destination-out";
+        }
+        else if (operation === "destination-over") {
+            return "destination-over";
+        }
+        else if (operation === "xor") {
+            return "xor";
+        }
+        else if (operation === "source-in") {
+            return "experimental-source-in";
+        }
+        else if (operation === "source-out") {
+            return "experimental-source-out";
+        }
+        else if (operation === "destination-in") {
+            return "experimental-destination-in";
+        }
+        else if (operation === "destination-atop") {
+            return "experimental-destination-atop";
+        }
+        throw new Error(`unknown composite operation: ${operation}`);
+    }
+    static toContext2D(operation) {
+        if (operation === "source-over") {
+            return "source-over";
+        }
+        else if (operation === "source-atop") {
+            return "source-atop";
+        }
+        else if (operation === "lighter") {
+            return "lighter";
+        }
+        else if (operation === "copy") {
+            return "copy";
+        }
+        else if (operation === "destination-out") {
+            return "destination-out";
+        }
+        else if (operation === "destination-over") {
+            return "destination-over";
+        }
+        else if (operation === "xor") {
+            return "xor";
+        }
+        else if (operation === "experimental-source-in") {
+            return "source-in";
+        }
+        else if (operation === "experimental-source-out") {
+            return "source-out";
+        }
+        else if (operation === "experimental-destination-in") {
+            return "destination-in";
+        }
+        else if (operation === "experimental-destination-atop") {
+            return "destination-atop";
+        }
+        throw new Error(`unknown composite operation: ${operation}`);
+    }
+}
+exports.CompositeOperationConverter = CompositeOperationConverter;