@afterswf/playerglobal 0.0.0-stage → 0.2.460

package/dist/lib/media/SoundChannel.js

@@ -0,0 +1,152 @@
+import { __extends } from "tslib";
+import { EventDispatcher } from '../events/EventDispatcher';
+import { release } from '@awayfl/swf-loader';
+import { Event } from '../events/Event';
+import { SoundMixer } from './SoundMixer';
+import { BaseAudioChannel } from '@awayjs/core/dist/lib/managers/BaseAudioChannel';
+/**
+ * Dispatched when a sound has finished playing.
+ * @eventType	flash.events.Event.SOUND_COMPLETE
+ * [Event(name="soundComplete", type="flash.events.Event")]
+ *
+ * The SoundChannel class controls a sound in an application. Every sound
+ * is assigned to a sound channel, and the application can have multiple
+ * sound channels that are mixed together.
+ * The SoundChannel class contains a <codeph class="+ topic/ph pr-d/codeph ">stop()</codeph> method,
+ * properties for monitoring the amplitude (volume) of the channel, and a property for assigning a
+ * SoundTransform object to the channel.
+ */
+var SoundChannel = /** @class */ (function (_super) {
+    __extends(SoundChannel, _super);
+    function SoundChannel() {
+        return _super !== null && _super.apply(this, arguments) || this;
+    }
+    // for AVM1:
+    SoundChannel.prototype.axCallPublicProperty = function (value1, value2) {
+        return null;
+    };
+    SoundChannel.prototype.axGetPublicProperty = function (value) {
+        return null;
+    };
+    SoundChannel.prototype.axSetPublicProperty = function (value, value2) {
+        return null;
+    };
+    SoundChannel.prototype.axHasPublicProperty = function (value) {
+        return null;
+    };
+    SoundChannel.prototype.axDeletePublicProperty = function (value) {
+        return null;
+    };
+    SoundChannel.prototype.axGetEnumerableKeys = function () {
+        return [];
+    };
+    /* internal */ SoundChannel.prototype.init = function (channel, transform) {
+        this._channel = channel;
+        if (!this._channel) {
+            return;
+        }
+        this._channel.addEventListener(BaseAudioChannel.COMPLETE, this.soundCompleteInternal.bind(this));
+        this.soundTransform = transform;
+        SoundMixer._registerSoundSource(this);
+    };
+    Object.defineProperty(SoundChannel.prototype, "leftPeak", {
+        /**
+         * The current amplitude (volume) of the left channel, from 0 (silent) to 1 (full amplitude).
+         */
+        get: function () {
+            release || console.log('leftPeak not implemented yet in flash/SoundChannel');
+            return 0;
+        },
+        enumerable: false,
+        configurable: true
+    });
+    Object.defineProperty(SoundChannel.prototype, "position", {
+        /**
+         * When the sound is playing, the position property indicates in milliseconds the current point
+         * that is being played in the sound file. When the sound is stopped or paused, the
+         * position property indicates the last point that was played in the sound file.
+         *
+         *   A common use case is to save the value of the position property when the
+         * sound is stopped. You can resume the sound later by restarting it from that saved position.
+         * If the sound is looped, position is reset to 0 at the beginning of each loop.
+         */
+        get: function () {
+            return this._channel ? this._channel.currentTime : 0;
+        },
+        enumerable: false,
+        configurable: true
+    });
+    Object.defineProperty(SoundChannel.prototype, "rightPeak", {
+        /**
+         * The current amplitude (volume) of the right channel, from 0 (silent) to 1 (full amplitude).
+         */
+        get: function () {
+            release || console.log('rightPeak not implemented yet in flash/SoundChannel');
+            return 0;
+        },
+        enumerable: false,
+        configurable: true
+    });
+    Object.defineProperty(SoundChannel.prototype, "soundTransform", {
+        /**
+         * The SoundTransform object assigned to the sound channel. A SoundTransform object
+         * includes properties for setting volume, panning, left speaker assignment, and right
+         * speaker assignment.
+         */
+        get: function () {
+            //	we not create this in the constructor, because it gets overwritten from Sound in most cases anyway
+            //	but we still need a Soundtransform to be available in the getter
+            if (!this._soundTransform) {
+                this._soundTransform = new this.sec.flash.media.SoundTransform();
+            }
+            return this._soundTransform;
+        },
+        set: function (value) {
+            if (this._channel) {
+                this._channel.volume = (value.volume == null) ? 0 : value.volume;
+                this._channel.pan = (value.pan == null) ? 0 : value.pan;
+            }
+            this._soundTransform = value;
+        },
+        enumerable: false,
+        configurable: true
+    });
+    SoundChannel.prototype.soundCompleteInternal = function (event) {
+        this._stopInternally();
+        // we should dispatch sound events to channel, because some games use this
+        var complete = new this.sec.flash.events.Event(Event.SOUND_COMPLETE);
+        this.dispatchEvent(complete);
+    };
+    SoundChannel.prototype._stopInternally = function () {
+        SoundMixer._unregisterSoundSource(this);
+    };
+    /**
+     * Stops the sound playing in the channel.
+     * @langversion	3.0
+     * @playerversion	Flash 9
+     * @playerversion	Lite 4
+     * @refpath
+     */
+    SoundChannel.prototype.stop = function () {
+        if (!this._channel) {
+            release || console.log('SoundChannel.stop: No sound exists');
+            return;
+        }
+        this._stopInternally();
+        this._channel.stop();
+    };
+    // for ISoundSource
+    SoundChannel.prototype.stopSound = function () {
+        this.stop();
+    };
+    // for ISoundSource
+    SoundChannel.prototype.updateSoundLevels = function (volume) {
+        if (!this._channel) {
+            return;
+        }
+        this._soundTransform.volume = volume;
+        this._channel.volume = volume;
+    };
+    return SoundChannel;
+}(EventDispatcher));
+export { SoundChannel };

package/dist/lib/media/SoundLoaderContext.d.ts

@@ -0,0 +1,99 @@
+/**
+ * The SoundLoaderContext class provides security checks for files that load sound.
+ * SoundLoaderContext objects are passed as an argument to the constructor and the
+ * <codeph class="+ topic/ph pr-d/codeph ">load()</codeph> method of the Sound class.
+ *
+ */
+export declare class SoundLoaderContext {
+    /**
+     * Creates a new sound loader context object.
+     * @param	bufferTime	The number of seconds to preload a streaming sound into a buffer
+     *   before the sound starts to stream.
+     * @param	checkPolicyFile	Specifies whether the existence of a URL policy file
+     *   should be checked upon loading the object (true) or not.
+     */
+    constructor(bufferTime?: number, checkPolicyFile?: boolean);
+    /**
+     * The number of milliseconds to preload a streaming sound into a buffer
+     * before the sound starts to stream.
+     *
+     *   Note that you cannot override the value of SoundLoaderContext.bufferTime
+     * by setting the global SoundMixer.bufferTime property.
+     * The SoundMixer.bufferTime property affects the buffer time
+     * for embedded streaming sounds in a SWF file and is independent of dynamically created
+     * Sound objects (that is, Sound objects created in ActionScript).
+     * @langversion	3.0
+     * @playerversion	Flash 9
+     * @playerversion	Lite 4
+     */
+    bufferTime: number;
+    /**
+     * Specifies whether the application should try to download a URL policy file from the
+     * loaded sound's server before beginning to load the sound. This property applies to
+     * sound that is loaded from outside
+     * the calling file's own domain using the Sound.load() method.
+     *
+     *   Set this property to true when you load a sound from outside the
+     * calling file's own domain and code in the calling file needs low-level access to
+     * the sound's data. Examples of low-level access to a sound's data
+     * include referencing the Sound.id3 property to get an
+     * ID3Info object or calling the SoundMixer.computeSpectrum() method to get
+     * sound samples from the loaded sound. If you try to access sound data without
+     * setting the checkPolicyFile property to true at loading time,
+     * you may get a SecurityError exception because the required policy file has not been downloaded.
+     * If you don't need low-level access to the sound data that you are loading, avoid setting
+     * checkPolicyFile to true. Checking for a policy file consumes
+     * network bandwidth
+     * and might delay the start of your download, so it should only be done when necessary.
+     * When you call Sound.load() with SoundLoaderContext.checkPolicyFile set
+     * to true, Flash Player or AIR  must
+     * either successfully download a relevant URL policy file or determine that no such policy file
+     * exists before it begins downloading the specified sound.
+     * Flash Player or AIR performs the following
+     * actions, in this order, to verify the existence of a policy file:Flash Player or AIR considers policy
+     * files that have already been downloaded.Flash Player or AIR tries
+     * to download any pending policy files specified in calls to
+     * Security.loadPolicyFile().Flash Player or AIR tries to download a
+     * policy file from the default location that corresponds to the sound's URL, which is
+     * /crossdomain.xml on the same server as URLRequest.url.
+     * (The sound's URL is specified in the url property of the URLRequest object
+     * passed to Sound.load() or the Sound() constructor function.)In all cases, Flash Player or AIR
+     * requires that an appropriate policy file exist on the sound's server, that it provide access
+     * to the sound file at URLRequest.url by virtue of the policy file's location, and
+     * that it allow the domain of the calling file to access the sound, through one or more
+     * <allow-access-from> tags.
+     * If you set checkPolicyFile to true,
+     * Flash Player or AIR waits until the policy file is verified
+     * before loading the sound. You should wait to perform
+     * any low-level operations on the sound data, such as calling Sound.id3 or
+     * SoundMixer.computeSpectrum(), until progress and complete
+     * events are dispatched from the Sound object.
+     * If you set checkPolicyFile to true but no appropriate policy file is found,
+     * you will not receive an error until you perform an operation that requires
+     * a policy file, and then Flash Player or AIR throws a
+     * SecurityError exception. After you receive a complete
+     * event, you can test whether a relevant policy file was found by getting the value
+     * of Sound.id3 within a try block and seeing if a
+     * SecurityError is thrown.Be careful with checkPolicyFile if you are downloading sound from a URL that
+     * uses server-side HTTP redirects. Flash Player or AIR tries to retrieve policy files that
+     * correspond to the url property of the URLRequest object
+     * passed to Sound.load(). If the final
+     * sound file comes from a different URL because of HTTP redirects, then the initially downloaded
+     * policy files might not be applicable to the sound's final URL, which is the URL that matters
+     * in security decisions.If you find yourself in this situation, here is one possible solution.
+     * After you receive a progress or complete event, you can examine the value of
+     * the Sound.url property, which contains the sound's final URL.
+     * Then call the Security.loadPolicyFile() method
+     * with a policy file URL that you calculate based on the sound's final URL. Finally, poll the value
+     * of Sound.id3 until no exception is thrown.This does not apply to content in the AIR application sandbox.
+     * Content in the application sandbox always has programatic access to sound content, regardless
+     * of its origin.For more information related to security, see the Flash Player Developer Center Topic:
+     * Security.
+     * @langversion	3.0
+     * @playerversion	Flash 9
+     * @playerversion	Lite 4
+     * @internal	: please review at same time: checkPolicyFile property in LoaderContext, NetStream
+     */
+    checkPolicyFile: boolean;
+}
+//# sourceMappingURL=SoundLoaderContext.d.ts.map

package/dist/lib/media/SoundLoaderContext.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"SoundLoaderContext.d.ts","sourceRoot":"","sources":["../../../lib/media/SoundLoaderContext.ts"],"names":[],"mappings":"AACA;;;;;GAKG;AACH,qBAAa,kBAAkB;IAE9B;;;;;;OAMG;gBACU,UAAU,GAAE,MAAa,EAAE,eAAe,GAAE,OAAe;IAIxE;;;;;;;;;;;;OAYG;IACI,UAAU,EAAE,MAAM,CAAC;IAE1B;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;OAkEG;IACI,eAAe,EAAE,OAAO,CAAC;CAChC"}

package/dist/lib/media/SoundLoaderContext.js

@@ -0,0 +1,21 @@
+/**
+ * The SoundLoaderContext class provides security checks for files that load sound.
+ * SoundLoaderContext objects are passed as an argument to the constructor and the
+ * <codeph class="+ topic/ph pr-d/codeph ">load()</codeph> method of the Sound class.
+ *
+ */
+var SoundLoaderContext = /** @class */ (function () {
+    /**
+     * Creates a new sound loader context object.
+     * @param	bufferTime	The number of seconds to preload a streaming sound into a buffer
+     *   before the sound starts to stream.
+     * @param	checkPolicyFile	Specifies whether the existence of a URL policy file
+     *   should be checked upon loading the object (true) or not.
+     */
+    function SoundLoaderContext(bufferTime, checkPolicyFile) {
+        if (bufferTime === void 0) { bufferTime = 1000; }
+        if (checkPolicyFile === void 0) { checkPolicyFile = false; }
+    }
+    return SoundLoaderContext;
+}());
+export { SoundLoaderContext };

package/dist/lib/media/SoundMixer.d.ts

@@ -0,0 +1,49 @@
+import { ByteArray, ASObject } from '@awayfl/avm2';
+import { SoundTransform } from './SoundTransform';
+/**
+ * Copyright 2014 Mozilla Foundation
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+export interface ISoundSource {
+    soundTransform: SoundTransform;
+    updateSoundLevels(volume: number): any;
+    stopSound(): any;
+}
+export declare class SoundMixer extends ASObject {
+    static classInitializer: any;
+    static classSymbols: string[];
+    static instanceSymbols: string[];
+    constructor();
+    private static _masterVolume;
+    private static _registeredSoundSources;
+    private static _bufferTime;
+    static _soundTransform: SoundTransform;
+    static get bufferTime(): number;
+    static set bufferTime(bufferTime: number);
+    static get soundTransform(): SoundTransform;
+    static set soundTransform(sndTransform: SoundTransform);
+    static get audioPlaybackMode(): string;
+    static set audioPlaybackMode(_value: string);
+    static get useSpeakerphoneForVoice(): boolean;
+    static set useSpeakerphoneForVoice(_value: boolean);
+    static stopAll(): void;
+    static computeSpectrum(outputArray: ByteArray, _FFTMode?: boolean, _stretchFactor?: number): void;
+    static areSoundsInaccessible(): boolean;
+    static _getMasterVolume(): number;
+    static _setMasterVolume(volume: any): void;
+    static _registerSoundSource(source: ISoundSource): void;
+    static _unregisterSoundSource(source: ISoundSource): void;
+    static _updateAllSoundSources(): void;
+}
+//# sourceMappingURL=SoundMixer.d.ts.map

package/dist/lib/media/SoundMixer.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"SoundMixer.d.ts","sourceRoot":"","sources":["../../../lib/media/SoundMixer.ts"],"names":[],"mappings":"AACA,OAAO,EAAE,SAAS,EAAE,QAAQ,EAAE,MAAM,cAAc,CAAC;AACnD,OAAO,EAAE,cAAc,EAAE,MAAM,kBAAkB,CAAC;AAIlD;;;;;;;;;;;;;;GAcG;AAGH,MAAM,WAAW,YAAY;IAC5B,cAAc,EAAE,cAAc,CAAC;IAC/B,iBAAiB,CAAC,MAAM,EAAE,MAAM,OAAE;IAClC,SAAS,QAAG;CACZ;AAED,qBAAa,UAAW,SAAQ,QAAQ;IAGvC,MAAM,CAAC,gBAAgB,EAAE,GAAG,CAAQ;IAGpC,MAAM,CAAC,YAAY,EAAE,MAAM,EAAG,CAAQ;IAGtC,MAAM,CAAC,eAAe,EAAE,MAAM,EAAG,CAAQ;;IAMzC,OAAO,CAAC,MAAM,CAAC,aAAa,CAAK;IACjC,OAAO,CAAC,MAAM,CAAC,uBAAuB,CAAsB;IAC5D,OAAO,CAAC,MAAM,CAAC,WAAW,CAAK;IAC/B,MAAM,CAAC,eAAe,EAAE,cAAc,CAAC;IAIvC,MAAM,KAAK,UAAU,IAAI,MAAM,CAG9B;IAED,MAAM,KAAK,UAAU,CAAC,UAAU,EAAE,MAAM,EAGvC;IAED,MAAM,KAAK,cAAc,IAAI,cAAc,CAM1C;IAED,MAAM,KAAK,cAAc,CAAC,YAAY,EAAE,cAAc,EAMrD;IAED,MAAM,KAAK,iBAAiB,IAAI,MAAM,CAGrC;IAED,MAAM,KAAK,iBAAiB,CAAC,MAAM,EAAE,MAAM,EAG1C;IAED,MAAM,KAAK,uBAAuB,IAAI,OAAO,CAG5C;IAED,MAAM,KAAK,uBAAuB,CAAC,MAAM,EAAE,OAAO,EAGjD;IAED,MAAM,CAAC,OAAO,IAAI,IAAI;IAOtB,MAAM,CAAC,eAAe,CACrB,WAAW,EAAE,SAAS,EACtB,QAAQ,GAAE,OAAe,EACzB,cAAc,GAAE,MAAkB,GAChC,IAAI;IAUP,MAAM,CAAC,qBAAqB,IAAI,OAAO;IAIvC,MAAM,CAAC,gBAAgB,IAAI,MAAM;IAIjC,MAAM,CAAC,gBAAgB,CAAC,MAAM,KAAA;IAM9B,MAAM,CAAC,oBAAoB,CAAC,MAAM,EAAE,YAAY;IAIhD,MAAM,CAAC,sBAAsB,CAAC,MAAM,EAAE,YAAY;IAOlD,MAAM,CAAC,sBAAsB;CAQ7B"}

package/dist/lib/media/SoundMixer.js

@@ -0,0 +1,126 @@
+import { __extends } from "tslib";
+import { somewhatImplemented, release, notImplemented, isNullOrUndefined } from '@awayfl/swf-loader';
+import { ASObject } from '@awayfl/avm2';
+import { SoundTransform } from './SoundTransform';
+import { MovieClip as AwayMovieClip } from '@awayjs/scene';
+import { AudioManager } from '@awayjs/core';
+var SoundMixer = /** @class */ (function (_super) {
+    __extends(SoundMixer, _super);
+    function SoundMixer() {
+        return _super.call(this) || this;
+    }
+    Object.defineProperty(SoundMixer, "bufferTime", {
+        // static _audioPlaybackMode: string;
+        // static _useSpeakerphoneForVoice: boolean;
+        get: function () {
+            release || notImplemented('public flash.media.SoundMixer::get bufferTime');
+            return SoundMixer._bufferTime;
+        },
+        set: function (bufferTime /*int*/) {
+            release || somewhatImplemented('public flash.media.SoundMixer::set bufferTime');
+            SoundMixer._bufferTime = bufferTime | 0;
+        },
+        enumerable: false,
+        configurable: true
+    });
+    Object.defineProperty(SoundMixer, "soundTransform", {
+        get: function () {
+            release || somewhatImplemented('public flash.media.SoundMixer::get soundTransform');
+            return isNullOrUndefined(SoundMixer._soundTransform) ?
+                new SoundTransform() :
+                new SoundTransform(SoundMixer._soundTransform.volume, SoundMixer._soundTransform.pan);
+        },
+        set: function (sndTransform) {
+            release || somewhatImplemented('public flash.media.SoundMixer::set soundTransform');
+            SoundMixer._soundTransform = isNullOrUndefined(sndTransform) ?
+                new SoundTransform() :
+                sndTransform;
+            SoundMixer._updateAllSoundSources();
+        },
+        enumerable: false,
+        configurable: true
+    });
+    Object.defineProperty(SoundMixer, "audioPlaybackMode", {
+        get: function () {
+            release || notImplemented('public flash.media.SoundMixer::get audioPlaybackMode');
+            return;
+            // return SoundMixer._audioPlaybackMode;
+        },
+        set: function (_value) {
+            release || notImplemented('public flash.media.SoundMixer::set audioPlaybackMode');
+            return;
+            // SoundMixer._audioPlaybackMode = value;
+        },
+        enumerable: false,
+        configurable: true
+    });
+    Object.defineProperty(SoundMixer, "useSpeakerphoneForVoice", {
+        get: function () {
+            release || notImplemented('public flash.media.SoundMixer::get useSpeakerphoneForVoice');
+            return;
+            // return SoundMixer._useSpeakerphoneForVoice;
+        },
+        set: function (_value) {
+            release || notImplemented('public flash.media.SoundMixer::set useSpeakerphoneForVoice');
+            return;
+            // SoundMixer._useSpeakerphoneForVoice = value;
+        },
+        enumerable: false,
+        configurable: true
+    });
+    SoundMixer.stopAll = function () {
+        SoundMixer._registeredSoundSources.forEach(function (e) { return e.stopSound(); });
+        SoundMixer._registeredSoundSources = [];
+        AwayMovieClip.stopSounds();
+    };
+    SoundMixer.computeSpectrum = function (outputArray, _FFTMode, _stretchFactor) {
+        if (_FFTMode === void 0) { _FFTMode = false; }
+        if (_stretchFactor === void 0) { _stretchFactor = 0; }
+        release || somewhatImplemented('public flash.media.SoundMixer::static computeSpectrum');
+        var data = new Float32Array(1024);
+        for (var i = 0; i < 1024; i++) {
+            data[i] = Math.random();
+        }
+        outputArray.writeRawBytes(data);
+        outputArray.position = 0;
+    };
+    SoundMixer.areSoundsInaccessible = function () {
+        release || notImplemented('public flash.media.SoundMixer::static areSoundsInaccessible');
+        return;
+    };
+    SoundMixer._getMasterVolume = function () {
+        return SoundMixer._masterVolume;
+    };
+    SoundMixer._setMasterVolume = function (volume) {
+        volume = +volume;
+        SoundMixer._masterVolume = volume;
+        SoundMixer._updateAllSoundSources();
+    };
+    SoundMixer._registerSoundSource = function (source) {
+        SoundMixer._registeredSoundSources.push(source);
+    };
+    SoundMixer._unregisterSoundSource = function (source) {
+        var index = SoundMixer._registeredSoundSources.indexOf(source);
+        if (index >= 0) {
+            SoundMixer._registeredSoundSources.splice(index, 1);
+        }
+    };
+    SoundMixer._updateAllSoundSources = function () {
+        var volume = SoundMixer._getMasterVolume();
+        if (SoundMixer._soundTransform) {
+            volume *= SoundMixer._soundTransform.volume;
+        }
+        AudioManager.setVolume(volume, -1);
+    };
+    // Called whenever the class is initialized.
+    SoundMixer.classInitializer = null;
+    // List of static symbols to link.
+    SoundMixer.classSymbols = null; // [];
+    // List of instance symbols to link.
+    SoundMixer.instanceSymbols = null; // [];
+    SoundMixer._masterVolume = 1;
+    SoundMixer._registeredSoundSources = [];
+    SoundMixer._bufferTime = 0;
+    return SoundMixer;
+}(ASObject));
+export { SoundMixer };

package/dist/lib/media/SoundTransform.d.ts

@@ -0,0 +1,64 @@
+import { ASObject, AXClass } from '@awayfl/avm2';
+/**
+ * The SoundTransform class contains properties for volume and panning.
+ *
+ */
+export declare class SoundTransform extends ASObject {
+    static axClass: typeof SoundTransform & AXClass;
+    axCallPublicProperty(value1: any, value2: any): any;
+    axGetPublicProperty(value: any): any;
+    axSetPublicProperty(value: any, value2: any): any;
+    axHasPublicProperty(value: any): any;
+    axDeletePublicProperty(value: any): any;
+    axGetEnumerableKeys(): string[];
+    private _vol;
+    private _pan;
+    /**
+     * Creates a SoundTransform object.
+     * @param	vol	The volume, ranging from 0 (silent) to 1 (full volume).
+     * @param	panning	The left-to-right panning of the sound, ranging from -1 (full pan left)
+     *   to 1 (full pan right). A value of 0 represents no panning (center).
+     * @langversion	3.0
+     * @playerversion	Flash 9
+     * @playerversion	Lite 4
+     * @refpath
+     */
+    constructor(vol?: number, panning?: number);
+    /**
+     * A value, from 0 (none) to 1 (all), specifying how much of the left input is played in the
+     * left speaker.
+     */
+    get leftToLeft(): number;
+    set leftToLeft(leftToLeft: number);
+    /**
+     * A value, from 0 (none) to 1 (all), specifying how much of the left input is played in the
+     * right speaker.
+     */
+    get leftToRight(): number;
+    set leftToRight(leftToRight: number);
+    /**
+     * The left-to-right panning of the sound, ranging from -1 (full pan left)
+     * to 1 (full pan right). A value of 0 represents no panning (balanced center between
+     * right and left).
+     */
+    get pan(): number;
+    set pan(value: number);
+    /**
+     * A value, from 0 (none) to 1 (all), specifying how much of the right input is played in the
+     * left speaker.
+     */
+    get rightToLeft(): number;
+    set rightToLeft(rightToLeft: number);
+    /**
+     * A value, from 0 (none) to 1 (all), specifying how much of the right input is played in the
+     * right speaker.
+     */
+    get rightToRight(): number;
+    set rightToRight(rightToRight: number);
+    /**
+     * The volume, ranging from 0 (silent) to 1 (full volume).
+     */
+    get volume(): number;
+    set volume(value: number);
+}
+//# sourceMappingURL=SoundTransform.d.ts.map

package/dist/lib/media/SoundTransform.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"SoundTransform.d.ts","sourceRoot":"","sources":["../../../lib/media/SoundTransform.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,QAAQ,EAAE,OAAO,EAAE,MAAM,cAAc,CAAC;AAEjD;;;GAGG;AACH,qBAAa,cAAe,SAAQ,QAAQ;IAE3C,MAAM,CAAC,OAAO,EAAE,OAAO,cAAc,GAAG,OAAO,CAAC;IAEzC,oBAAoB,CAAC,MAAM,EAAE,GAAG,EAAE,MAAM,EAAE,GAAG,GAAG,GAAG;IAKnD,mBAAmB,CAAC,KAAK,EAAE,GAAG,GAAG,GAAG;IAKpC,mBAAmB,CAAC,KAAK,EAAE,GAAG,EAAE,MAAM,EAAE,GAAG,GAAG,GAAG;IAKjD,mBAAmB,CAAC,KAAK,EAAE,GAAG,GAAG,GAAG;IAKpC,sBAAsB,CAAC,KAAK,EAAE,GAAG,GAAG,GAAG;IAKvC,mBAAmB,IAAI,MAAM,EAAE;IAKtC,OAAO,CAAC,IAAI,CAAa;IACzB,OAAO,CAAC,IAAI,CAAa;IACzB;;;;;;;;;OASG;gBACU,GAAG,GAAE,MAAU,EAAE,OAAO,GAAE,MAAU;IAMjD;;;OAGG;IACH,IAAW,UAAU,IAAK,MAAM,CAG/B;IAED,IAAW,UAAU,CAAE,UAAU,EAAE,MAAM,EAExC;IAED;;;OAGG;IACH,IAAW,WAAW,IAAK,MAAM,CAGhC;IAED,IAAW,WAAW,CAAE,WAAW,EAAE,MAAM,EAE1C;IAED;;;;OAIG;IACH,IAAW,GAAG,IAAK,MAAM,CAExB;IAED,IAAW,GAAG,CAAE,KAAK,EAAE,MAAM,EAE5B;IAED;;;OAGG;IACH,IAAW,WAAW,IAAK,MAAM,CAGhC;IAED,IAAW,WAAW,CAAE,WAAW,EAAE,MAAM,EAE1C;IAED;;;OAGG;IACH,IAAW,YAAY,IAAK,MAAM,CAGjC;IAED,IAAW,YAAY,CAAE,YAAY,EAAE,MAAM,EAE5C;IAED;;OAEG;IACH,IAAW,MAAM,IAAK,MAAM,CAE3B;IAED,IAAW,MAAM,CAAE,KAAK,EAAE,MAAM,EAI/B;CAED"}

package/dist/lib/media/SoundTransform.js

@@ -0,0 +1,146 @@
+import { __extends } from "tslib";
+import { ASObject } from '@awayfl/avm2';
+/**
+ * The SoundTransform class contains properties for volume and panning.
+ *
+ */
+var SoundTransform = /** @class */ (function (_super) {
+    __extends(SoundTransform, _super);
+    /**
+     * Creates a SoundTransform object.
+     * @param	vol	The volume, ranging from 0 (silent) to 1 (full volume).
+     * @param	panning	The left-to-right panning of the sound, ranging from -1 (full pan left)
+     *   to 1 (full pan right). A value of 0 represents no panning (center).
+     * @langversion	3.0
+     * @playerversion	Flash 9
+     * @playerversion	Lite 4
+     * @refpath
+     */
+    function SoundTransform(vol, panning) {
+        if (vol === void 0) { vol = 1; }
+        if (panning === void 0) { panning = 0; }
+        var _this = _super.call(this) || this;
+        _this._vol = 1;
+        _this._pan = 0;
+        _this._vol = vol;
+        _this._pan = panning;
+        return _this;
+    }
+    // for AVM1:
+    SoundTransform.prototype.axCallPublicProperty = function (value1, value2) {
+        console.log('axCallPublicProperty not implemented yet in flash/SoundTransform');
+        return null;
+    };
+    SoundTransform.prototype.axGetPublicProperty = function (value) {
+        console.log('axGetPublicProperty not implemented yet in flash/SoundTransform');
+        return null;
+    };
+    SoundTransform.prototype.axSetPublicProperty = function (value, value2) {
+        console.log('axSetPublicProperty not implemented yet in flash/SoundTransform');
+        return null;
+    };
+    SoundTransform.prototype.axHasPublicProperty = function (value) {
+        console.log('axHasPublicProperty not implemented yet in flash/SoundTransform');
+        return null;
+    };
+    SoundTransform.prototype.axDeletePublicProperty = function (value) {
+        console.log('axDeletePublicProperty not implemented yet in flash/SoundTransform');
+        return null;
+    };
+    SoundTransform.prototype.axGetEnumerableKeys = function () {
+        console.log('axGetEnumerableKeys not implemented yet in flash/SoundTransform');
+        return [];
+    };
+    Object.defineProperty(SoundTransform.prototype, "leftToLeft", {
+        /**
+         * A value, from 0 (none) to 1 (all), specifying how much of the left input is played in the
+         * left speaker.
+         */
+        get: function () {
+            console.log('leftToLeft not implemented yet in flash/SoundTransform');
+            return 0;
+        },
+        set: function (leftToLeft) {
+            console.log('leftToLeft not implemented yet in flash/SoundTransform');
+        },
+        enumerable: false,
+        configurable: true
+    });
+    Object.defineProperty(SoundTransform.prototype, "leftToRight", {
+        /**
+         * A value, from 0 (none) to 1 (all), specifying how much of the left input is played in the
+         * right speaker.
+         */
+        get: function () {
+            console.log('leftToRight not implemented yet in flash/SoundTransform');
+            return 0;
+        },
+        set: function (leftToRight) {
+            console.log('leftToRight not implemented yet in flash/SoundTransform');
+        },
+        enumerable: false,
+        configurable: true
+    });
+    Object.defineProperty(SoundTransform.prototype, "pan", {
+        /**
+         * The left-to-right panning of the sound, ranging from -1 (full pan left)
+         * to 1 (full pan right). A value of 0 represents no panning (balanced center between
+         * right and left).
+         */
+        get: function () {
+            return this._pan;
+        },
+        set: function (value) {
+            this._pan = value;
+        },
+        enumerable: false,
+        configurable: true
+    });
+    Object.defineProperty(SoundTransform.prototype, "rightToLeft", {
+        /**
+         * A value, from 0 (none) to 1 (all), specifying how much of the right input is played in the
+         * left speaker.
+         */
+        get: function () {
+            console.log('rightToLeft not implemented yet in flash/SoundTransform');
+            return 0;
+        },
+        set: function (rightToLeft) {
+            console.log('rightToLeft not implemented yet in flash/SoundTransform');
+        },
+        enumerable: false,
+        configurable: true
+    });
+    Object.defineProperty(SoundTransform.prototype, "rightToRight", {
+        /**
+         * A value, from 0 (none) to 1 (all), specifying how much of the right input is played in the
+         * right speaker.
+         */
+        get: function () {
+            console.log('rightToRight not implemented yet in flash/SoundTransform');
+            return 0;
+        },
+        set: function (rightToRight) {
+            console.log('rightToRight not implemented yet in flash/SoundTransform');
+        },
+        enumerable: false,
+        configurable: true
+    });
+    Object.defineProperty(SoundTransform.prototype, "volume", {
+        /**
+         * The volume, ranging from 0 (silent) to 1 (full volume).
+         */
+        get: function () {
+            return this._vol;
+        },
+        set: function (value) {
+            this._vol = (value > 1)
+                ? 1
+                : (value < 0 ? 0 : value);
+        },
+        enumerable: false,
+        configurable: true
+    });
+    return SoundTransform;
+}(ASObject));
+export { SoundTransform };