react-native-audio-api 0.11.0-alpha.0 → 0.11.0-alpha.10

package/ios/audioapi/ios/system/notification/PlaybackNotification.mm

@@ -0,0 +1,427 @@
+#import <audioapi/ios/AudioAPIModule.h>
+#import <audioapi/ios/system/notification/PlaybackNotification.h>
+
+#define NOW_PLAYING_INFO_KEYS \
+  @{ \
+    @"title" : MPMediaItemPropertyTitle, \
+    @"artist" : MPMediaItemPropertyArtist, \
+    @"album" : MPMediaItemPropertyAlbumTitle, \
+    @"duration" : MPMediaItemPropertyPlaybackDuration, \
+    @"elapsedTime" : MPNowPlayingInfoPropertyElapsedPlaybackTime, \
+    @"speed" : MPNowPlayingInfoPropertyPlaybackRate, \
+    @"artwork" : MPMediaItemPropertyArtwork \
+  }
+
+@implementation PlaybackNotification {
+  BOOL _isInitialized;
+  NSMutableDictionary *_currentInfo;
+}
+
+- (instancetype)initWithAudioAPIModule:(AudioAPIModule *)audioAPIModule
+{
+  if (self = [super init]) {
+    self.audioAPIModule = audioAPIModule;
+    self.playingInfoCenter = [MPNowPlayingInfoCenter defaultCenter];
+    _isInitialized = false;
+    _isActive = false;
+    _currentInfo = [[NSMutableDictionary alloc] init];
+  }
+
+  return self;
+}
+
+#pragma mark - BaseNotification Protocol
+
+- (BOOL)initializeWithOptions:(NSDictionary *)options
+{
+  if (_isInitialized) {
+    return true;
+  }
+
+  // Enable remote control events
+  dispatch_async(dispatch_get_main_queue(), ^{
+    [[UIApplication sharedApplication] beginReceivingRemoteControlEvents];
+  });
+
+  // Enable default remote commands
+  [self enableRemoteCommand:@"play" enabled:true];
+  [self enableRemoteCommand:@"pause" enabled:true];
+  [self enableRemoteCommand:@"next" enabled:true];
+  [self enableRemoteCommand:@"previous" enabled:true];
+  [self enableRemoteCommand:@"skipForward" enabled:true];
+  [self enableRemoteCommand:@"skipBackward" enabled:true];
+  [self enableRemoteCommand:@"seek" enabled:true];
+
+  _isInitialized = true;
+  return true;
+}
+
+- (BOOL)showWithOptions:(NSDictionary *)options
+{
+  if (!_isInitialized) {
+    if (![self initializeWithOptions:options]) {
+      return false;
+    }
+  }
+
+  // Update the now playing info
+  [self updateNowPlayingInfo:options];
+
+  _isActive = true;
+
+  return true;
+}
+
+- (BOOL)updateWithOptions:(NSDictionary *)options
+{
+  if (!_isActive) {
+    return false;
+  }
+
+  // Handle control enable/disable
+  if (options[@"control"] && options[@"enabled"]) {
+    NSString *control = options[@"control"];
+    BOOL enabled = [options[@"enabled"] boolValue];
+    [self enableControl:control enabled:enabled];
+    return true;
+  }
+
+  // Update the now playing info
+  [self updateNowPlayingInfo:options];
+
+  return true;
+}
+
+- (BOOL)hide
+{
+  if (!_isActive) {
+    return true;
+  }
+
+  // Clear now playing info
+  self.playingInfoCenter.nowPlayingInfo = nil;
+  self.artworkUrl = nil;
+  [_currentInfo removeAllObjects];
+
+  _isActive = false;
+
+  return true;
+}
+
+- (void)cleanup
+{
+  // Hide if active
+  if (_isActive) {
+    [self hide];
+  }
+
+  // Disable all remote commands
+  MPRemoteCommandCenter *remoteCenter = [MPRemoteCommandCenter sharedCommandCenter];
+  [remoteCenter.playCommand removeTarget:self];
+  [remoteCenter.pauseCommand removeTarget:self];
+  [remoteCenter.stopCommand removeTarget:self];
+  [remoteCenter.togglePlayPauseCommand removeTarget:self];
+  [remoteCenter.nextTrackCommand removeTarget:self];
+  [remoteCenter.previousTrackCommand removeTarget:self];
+  [remoteCenter.skipForwardCommand removeTarget:self];
+  [remoteCenter.skipBackwardCommand removeTarget:self];
+  [remoteCenter.seekForwardCommand removeTarget:self];
+  [remoteCenter.seekBackwardCommand removeTarget:self];
+  [remoteCenter.changePlaybackPositionCommand removeTarget:self];
+
+  // Disable remote control events
+  dispatch_async(dispatch_get_main_queue(), ^{
+    [[UIApplication sharedApplication] endReceivingRemoteControlEvents];
+  });
+
+  _isInitialized = false;
+}
+
+- (BOOL)isActive
+{
+  return _isActive;
+}
+
+- (NSString *)getNotificationType
+{
+  return @"playback";
+}
+
+#pragma mark - Private Methods
+
+- (void)updateNowPlayingInfo:(NSDictionary *)info
+{
+  if (!info) {
+    return;
+  }
+
+  // Get existing now playing info or create new one
+  NSMutableDictionary *nowPlayingInfo = [self.playingInfoCenter.nowPlayingInfo mutableCopy];
+  if (!nowPlayingInfo) {
+    nowPlayingInfo = [[NSMutableDictionary alloc] init];
+  }
+
+  // Map keys from our API to MPNowPlayingInfoCenter keys
+  NSDictionary *keyMap = NOW_PLAYING_INFO_KEYS;
+
+  // Only update the keys that are provided in this update
+  for (NSString *key in info) {
+    NSString *mpKey = keyMap[key];
+    if (mpKey) {
+      // Handle artwork specially - don't set it directly to nowPlayingInfo
+      if ([key isEqualToString:@"artwork"]) {
+        _currentInfo[key] = info[key];
+      } else {
+        nowPlayingInfo[mpKey] = info[key];
+        _currentInfo[key] = info[key];
+      }
+    }
+  }
+
+  self.playingInfoCenter.nowPlayingInfo = nowPlayingInfo;
+
+  // Handle playback state
+  NSString *state = _currentInfo[@"state"];
+  MPNowPlayingPlaybackState playbackState = MPNowPlayingPlaybackStatePaused;
+
+  if (state) {
+    if ([state isEqualToString:@"playing"]) {
+      playbackState = MPNowPlayingPlaybackStatePlaying;
+    } else if ([state isEqualToString:@"paused"]) {
+      playbackState = MPNowPlayingPlaybackStatePaused;
+    } else {
+      playbackState = MPNowPlayingPlaybackStatePaused;
+    }
+  }
+
+  self.playingInfoCenter.playbackState = playbackState;
+
+  // Handle artwork
+  NSString *artworkUrl = [self getArtworkUrl:_currentInfo[@"artwork"]];
+  [self updateArtworkIfNeeded:artworkUrl];
+}
+
+- (NSString *)getArtworkUrl:(id)artwork
+{
+  if (!artwork) {
+    return nil;
+  }
+
+  // Handle both string and dictionary formats
+  if ([artwork isKindOfClass:[NSString class]]) {
+    return artwork;
+  } else if ([artwork isKindOfClass:[NSDictionary class]]) {
+    return artwork[@"uri"];
+  }
+
+  return nil;
+}
+
+- (void)updateArtworkIfNeeded:(NSString *)artworkUrl
+{
+  if (!artworkUrl) {
+    return;
+  }
+
+  MPNowPlayingInfoCenter *center = [MPNowPlayingInfoCenter defaultCenter];
+  if ([artworkUrl isEqualToString:self.artworkUrl] &&
+      center.nowPlayingInfo[MPMediaItemPropertyArtwork] != nil) {
+    return;
+  }
+
+  self.artworkUrl = artworkUrl;
+
+  // Load artwork asynchronously
+  dispatch_async(dispatch_get_global_queue(DISPATCH_QUEUE_PRIORITY_BACKGROUND, 0), ^{
+    NSURL *url = nil;
+    NSData *imageData = nil;
+    UIImage *image = nil;
+
+    @try {
+      if ([artworkUrl hasPrefix:@"http://"] || [artworkUrl hasPrefix:@"https://"]) {
+        // Remote URL
+        url = [NSURL URLWithString:artworkUrl];
+        imageData = [NSData dataWithContentsOfURL:url];
+      } else {
+        // Local file - try as resource or file path
+        NSString *imagePath = [[NSBundle mainBundle] pathForResource:artworkUrl ofType:nil];
+        if (imagePath) {
+          imageData = [NSData dataWithContentsOfFile:imagePath];
+        } else {
+          // Try as absolute path
+          imageData = [NSData dataWithContentsOfFile:artworkUrl];
+        }
+      }
+
+      if (imageData) {
+        image = [UIImage imageWithData:imageData];
+      }
+    } @catch (NSException *exception) {
+      // Failed to load artwork
+    }
+
+    if (image) {
+      MPMediaItemArtwork *artwork = [[MPMediaItemArtwork alloc]
+          initWithBoundsSize:image.size
+              requestHandler:^UIImage *_Nonnull(CGSize size) { return image; }];
+
+      dispatch_async(dispatch_get_main_queue(), ^{
+        NSMutableDictionary *nowPlayingInfo = [center.nowPlayingInfo mutableCopy];
+        if (!nowPlayingInfo) {
+          nowPlayingInfo = [[NSMutableDictionary alloc] init];
+        }
+        nowPlayingInfo[MPMediaItemPropertyArtwork] = artwork;
+        center.nowPlayingInfo = nowPlayingInfo;
+      });
+    }
+  });
+}
+
+- (void)enableControl:(NSString *)control enabled:(BOOL)enabled
+{
+  NSSet *validControls = [NSSet setWithObjects:@"play",
+                                               @"pause",
+                                               @"next",
+                                               @"previous",
+                                               @"skipForward",
+                                               @"skipBackward",
+                                               @"seek",
+                                               nil];
+  if ([validControls containsObject:control]) {
+    [self enableRemoteCommand:control enabled:enabled];
+  }
+}
+
+- (void)enableRemoteCommand:(NSString *)name enabled:(BOOL)enabled
+{
+  MPRemoteCommandCenter *remoteCenter = [MPRemoteCommandCenter sharedCommandCenter];
+
+  if ([name isEqualToString:@"play"]) {
+    [self enableCommand:remoteCenter.playCommand withSelector:@selector(onPlay:) enabled:enabled];
+  } else if ([name isEqualToString:@"pause"]) {
+    [self enableCommand:remoteCenter.pauseCommand withSelector:@selector(onPause:) enabled:enabled];
+  } else if ([name isEqualToString:@"stop"]) {
+    [self enableCommand:remoteCenter.stopCommand withSelector:@selector(onStop:) enabled:enabled];
+  } else if ([name isEqualToString:@"togglePlayPause"]) {
+    [self enableCommand:remoteCenter.togglePlayPauseCommand
+           withSelector:@selector(onTogglePlayPause:)
+                enabled:enabled];
+  } else if ([name isEqualToString:@"next"]) {
+    [self enableCommand:remoteCenter.nextTrackCommand
+           withSelector:@selector(onNextTrack:)
+                enabled:enabled];
+  } else if ([name isEqualToString:@"previous"]) {
+    [self enableCommand:remoteCenter.previousTrackCommand
+           withSelector:@selector(onPreviousTrack:)
+                enabled:enabled];
+  } else if ([name isEqualToString:@"skipForward"]) {
+    remoteCenter.skipForwardCommand.preferredIntervals = @[ @(15) ];
+    [self enableCommand:remoteCenter.skipForwardCommand
+           withSelector:@selector(onSkipForward:)
+                enabled:enabled];
+  } else if ([name isEqualToString:@"skipBackward"]) {
+    remoteCenter.skipBackwardCommand.preferredIntervals = @[ @(15) ];
+    [self enableCommand:remoteCenter.skipBackwardCommand
+           withSelector:@selector(onSkipBackward:)
+                enabled:enabled];
+  } else if ([name isEqualToString:@"seekForward"]) {
+    [self enableCommand:remoteCenter.seekForwardCommand
+           withSelector:@selector(onSeekForward:)
+                enabled:enabled];
+  } else if ([name isEqualToString:@"seekBackward"]) {
+    [self enableCommand:remoteCenter.seekBackwardCommand
+           withSelector:@selector(onSeekBackward:)
+                enabled:enabled];
+  } else if ([name isEqualToString:@"seek"]) {
+    [self enableCommand:remoteCenter.changePlaybackPositionCommand
+           withSelector:@selector(onChangePlaybackPosition:)
+                enabled:enabled];
+  }
+}
+
+- (void)enableCommand:(MPRemoteCommand *)command withSelector:(SEL)selector enabled:(BOOL)enabled
+{
+  [command removeTarget:self];
+  command.enabled = enabled;
+  if (enabled) {
+    [command addTarget:self action:selector];
+  }
+}
+
+#pragma mark - Remote Command Handlers
+
+- (MPRemoteCommandHandlerStatus)onPlay:(MPRemoteCommandEvent *)event
+{
+  [self.audioAPIModule invokeHandlerWithEventName:@"playbackNotificationPlay" eventBody:@{}];
+  return MPRemoteCommandHandlerStatusSuccess;
+}
+
+- (MPRemoteCommandHandlerStatus)onPause:(MPRemoteCommandEvent *)event
+{
+  [self.audioAPIModule invokeHandlerWithEventName:@"playbackNotificationPause" eventBody:@{}];
+  return MPRemoteCommandHandlerStatusSuccess;
+}
+
+- (MPRemoteCommandHandlerStatus)onStop:(MPRemoteCommandEvent *)event
+{
+  [self.audioAPIModule invokeHandlerWithEventName:@"playbackNotificationStop" eventBody:@{}];
+  return MPRemoteCommandHandlerStatusSuccess;
+}
+
+- (MPRemoteCommandHandlerStatus)onTogglePlayPause:(MPRemoteCommandEvent *)event
+{
+  [self.audioAPIModule invokeHandlerWithEventName:@"playbackNotificationTogglePlayPause"
+                                        eventBody:@{}];
+  return MPRemoteCommandHandlerStatusSuccess;
+}
+
+- (MPRemoteCommandHandlerStatus)onNextTrack:(MPRemoteCommandEvent *)event
+{
+  [self.audioAPIModule invokeHandlerWithEventName:@"playbackNotificationNext" eventBody:@{}];
+  return MPRemoteCommandHandlerStatusSuccess;
+}
+
+- (MPRemoteCommandHandlerStatus)onPreviousTrack:(MPRemoteCommandEvent *)event
+{
+  [self.audioAPIModule invokeHandlerWithEventName:@"playbackNotificationPrevious" eventBody:@{}];
+  return MPRemoteCommandHandlerStatusSuccess;
+}
+
+- (MPRemoteCommandHandlerStatus)onSeekForward:(MPRemoteCommandEvent *)event
+{
+  [self.audioAPIModule invokeHandlerWithEventName:@"playbackNotificationSeekForward" eventBody:@{}];
+  return MPRemoteCommandHandlerStatusSuccess;
+}
+
+- (MPRemoteCommandHandlerStatus)onSeekBackward:(MPRemoteCommandEvent *)event
+{
+  [self.audioAPIModule invokeHandlerWithEventName:@"playbackNotificationSeekBackward"
+                                        eventBody:@{}];
+  return MPRemoteCommandHandlerStatusSuccess;
+}
+
+- (MPRemoteCommandHandlerStatus)onSkipForward:(MPSkipIntervalCommandEvent *)event
+{
+  NSDictionary *body = @{@"value" : @(event.interval)};
+  [self.audioAPIModule invokeHandlerWithEventName:@"playbackNotificationSkipForward"
+                                        eventBody:body];
+  return MPRemoteCommandHandlerStatusSuccess;
+}
+
+- (MPRemoteCommandHandlerStatus)onSkipBackward:(MPSkipIntervalCommandEvent *)event
+{
+  NSDictionary *body = @{@"value" : @(event.interval)};
+  [self.audioAPIModule invokeHandlerWithEventName:@"playbackNotificationSkipBackward"
+                                        eventBody:body];
+  return MPRemoteCommandHandlerStatusSuccess;
+}
+
+- (MPRemoteCommandHandlerStatus)onChangePlaybackPosition:
+    (MPChangePlaybackPositionCommandEvent *)event
+{
+  NSDictionary *body = @{@"value" : @(event.positionTime)};
+  [self.audioAPIModule invokeHandlerWithEventName:@"playbackNotificationSeekTo" eventBody:body];
+  return MPRemoteCommandHandlerStatusSuccess;
+}
+
+@end

package/lib/commonjs/AudioAPIModule/AudioAPIModule.js

@@ -0,0 +1,90 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.default = void 0;
+var _specs = require("../specs");
+// Hint: Copied from react-native-worklets
+// Doesn't really matter what is inside, just need a unique type
+
+class AudioAPIModule {
+  #workletsModule_ = null;
+  #canUseWorklets_ = false;
+  #workletsVersion = 'unknown';
+  #workletsAvailable_ = false;
+  supportedWorkletsVersion = ['0.6.0', '0.6.1'];
+  constructor() {
+    // Important! Verify and import worklets first
+    // otherwise the native module installation might crash
+    // if react-native-worklets is not imported before audio-api
+    this.#verifyWorklets();
+    if (this.#verifyInstallation()) {
+      return;
+    }
+    if (!_specs.NativeAudioAPIModule) {
+      throw new Error(`Failed to install react-native-audio-api: The native module could not be found.`);
+    }
+    _specs.NativeAudioAPIModule.install();
+  }
+  #verifyWorklets() {
+    try {
+      const workletsPackage = require('react-native-worklets');
+      const workletsPackageJson = require('react-native-worklets/package.json');
+      this.#workletsVersion = workletsPackageJson.version;
+      this.#workletsAvailable_ = true;
+      this.#canUseWorklets_ = this.supportedWorkletsVersion.includes(workletsPackageJson.version);
+      if (this.#canUseWorklets_) {
+        this.#workletsModule_ = workletsPackage;
+      }
+      return this.#canUseWorklets_;
+    } catch {
+      this.#canUseWorklets_ = false;
+      return false;
+    }
+  }
+  #verifyInstallation() {
+    return global.createAudioContext != null && global.createOfflineAudioContext != null && global.createAudioRecorder != null && global.createAudioDecoder != null && global.createAudioStretcher != null && global.AudioEventEmitter != null;
+  }
+  get workletsModule() {
+    return this.#workletsModule_;
+  }
+
+  /**
+   * Indicates whether react-native-worklets are installed in matching version,
+   * for usage with react-native-audio-api.
+   */
+  get canUseWorklets() {
+    return this.#canUseWorklets_;
+  }
+
+  /** Returns the installed worklets version or 'unknown'. */
+  get workletsVersion() {
+    return this.#workletsVersion;
+  }
+
+  /**
+   * Indicates whether react-native-worklets are installed, regardless of
+   * version support. Useful for asserting compatibility.
+   */
+  get areWorkletsAvailable() {
+    return this.#workletsAvailable_;
+  }
+
+  /**
+   * Indicates whether the installed react-native-worklets version is supported.
+   * Useful for asserting compatibility.
+   */
+  get isWorkletsVersionSupported() {
+    // Note: if areWorkletsAvailable is true, canUseWorklets is equivalent to version check
+    return this.#canUseWorklets_;
+  }
+  createAudioRuntime() {
+    if (!this.#canUseWorklets_) {
+      return null;
+    }
+    return this.#workletsModule_.createWorkletRuntime('AudioWorkletRuntime');
+  }
+}
+var _default = exports.default = new AudioAPIModule();
+//# sourceMappingURL=AudioAPIModule.js.map

package/lib/commonjs/AudioAPIModule/AudioAPIModule.js.map

@@ -0,0 +1 @@
+{"version":3,"names":["_specs","require","AudioAPIModule","workletsModule_","canUseWorklets_","workletsVersion","workletsAvailable_","supportedWorkletsVersion","constructor","verifyWorklets","verifyInstallation","NativeAudioAPIModule","Error","install","#verifyWorklets","workletsPackage","workletsPackageJson","version","includes","#verifyInstallation","global","createAudioContext","createOfflineAudioContext","createAudioRecorder","createAudioDecoder","createAudioStretcher","AudioEventEmitter","workletsModule","canUseWorklets","areWorkletsAvailable","isWorkletsVersionSupported","createAudioRuntime","createWorkletRuntime","_default","exports","default"],"sourceRoot":"../../../src","sources":["AudioAPIModule/AudioAPIModule.ts"],"mappings":";;;;;;AACA,IAAAA,MAAA,GAAAC,OAAA;AAEA;AACA;;AAcA,MAAMC,cAAc,CAAC;EACnB,CAACC,eAAe,GAA2B,IAAI;EAC/C,CAACC,eAAe,GAAG,KAAK;EACxB,CAACC,eAAe,GAAG,SAAS;EAC5B,CAACC,kBAAkB,GAAG,KAAK;EAEpBC,wBAAwB,GAAG,CAAC,OAAO,EAAE,OAAO,CAAC;EAEpDC,WAAWA,CAAA,EAAG;IACZ;IACA;IACA;IACA,IAAI,CAAC,CAACC,cAAc,CAAC,CAAC;IAEtB,IAAI,IAAI,CAAC,CAACC,kBAAkB,CAAC,CAAC,EAAE;MAC9B;IACF;IAEA,IAAI,CAACC,2BAAoB,EAAE;MACzB,MAAM,IAAIC,KAAK,CACb,iFACF,CAAC;IACH;IAEAD,2BAAoB,CAACE,OAAO,CAAC,CAAC;EAChC;EAEA,CAACJ,cAAcK,CAAA,EAAY;IACzB,IAAI;MACF,MAAMC,eAAe,GAAGd,OAAO,CAAC,uBAAuB,CAAC;MACxD,MAAMe,mBAAmB,GAAGf,OAAO,CAAC,oCAAoC,CAAC;MACzE,IAAI,CAAC,CAACI,eAAe,GAAGW,mBAAmB,CAACC,OAAO;MACnD,IAAI,CAAC,CAACX,kBAAkB,GAAG,IAAI;MAE/B,IAAI,CAAC,CAACF,eAAe,GAAG,IAAI,CAACG,wBAAwB,CAACW,QAAQ,CAC5DF,mBAAmB,CAACC,OACtB,CAAC;MAED,IAAI,IAAI,CAAC,CAACb,eAAe,EAAE;QACzB,IAAI,CAAC,CAACD,eAAe,GAAGY,eAAe;MACzC;MAEA,OAAO,IAAI,CAAC,CAACX,eAAe;IAC9B,CAAC,CAAC,MAAM;MACN,IAAI,CAAC,CAACA,eAAe,GAAG,KAAK;MAC7B,OAAO,KAAK;IACd;EACF;EAEA,CAACM,kBAAkBS,CAAA,EAAY;IAC7B,OACEC,MAAM,CAACC,kBAAkB,IAAI,IAAI,IACjCD,MAAM,CAACE,yBAAyB,IAAI,IAAI,IACxCF,MAAM,CAACG,mBAAmB,IAAI,IAAI,IAClCH,MAAM,CAACI,kBAAkB,IAAI,IAAI,IACjCJ,MAAM,CAACK,oBAAoB,IAAI,IAAI,IACnCL,MAAM,CAACM,iBAAiB,IAAI,IAAI;EAEpC;EAEA,IAAIC,cAAcA,CAAA,EAA2B;IAC3C,OAAO,IAAI,CAAC,CAACxB,eAAe;EAC9B;;EAEA;AACF;AACA;AACA;EACE,IAAIyB,cAAcA,CAAA,EAAY;IAC5B,OAAO,IAAI,CAAC,CAACxB,eAAe;EAC9B;;EAEA;EACA,IAAIC,eAAeA,CAAA,EAAW;IAC5B,OAAO,IAAI,CAAC,CAACA,eAAe;EAC9B;;EAEA;AACF;AACA;AACA;EACE,IAAIwB,oBAAoBA,CAAA,EAAY;IAClC,OAAO,IAAI,CAAC,CAACvB,kBAAkB;EACjC;;EAEA;AACF;AACA;AACA;EACE,IAAIwB,0BAA0BA,CAAA,EAAY;IACxC;IACA,OAAO,IAAI,CAAC,CAAC1B,eAAe;EAC9B;EAEO2B,kBAAkBA,CAAA,EAA0B;IACjD,IAAI,CAAC,IAAI,CAAC,CAAC3B,eAAe,EAAE;MAC1B,OAAO,IAAI;IACb;IAEA,OAAO,IAAI,CAAC,CAACD,eAAe,CAAE6B,oBAAoB,CAAC,qBAAqB,CAAC;EAC3E;AACF;AAAC,IAAAC,QAAA,GAAAC,OAAA,CAAAC,OAAA,GAEc,IAAIjC,cAAc,CAAC,CAAC","ignoreList":[]}

package/lib/commonjs/AudioAPIModule/globals.d.js

@@ -0,0 +1,6 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+//# sourceMappingURL=globals.d.js.map

package/lib/commonjs/AudioAPIModule/globals.d.js.map

@@ -0,0 +1 @@
+{"version":3,"names":[],"sourceRoot":"../../../src","sources":["AudioAPIModule/globals.d.ts"],"mappings":"","ignoreList":[]}

package/lib/commonjs/AudioAPIModule/index.js

@@ -0,0 +1,14 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+Object.defineProperty(exports, "default", {
+  enumerable: true,
+  get: function () {
+    return _AudioAPIModule.default;
+  }
+});
+var _AudioAPIModule = _interopRequireDefault(require("./AudioAPIModule"));
+function _interopRequireDefault(e) { return e && e.__esModule ? e : { default: e }; }
+//# sourceMappingURL=index.js.map

package/lib/commonjs/AudioAPIModule/index.js.map

@@ -0,0 +1 @@
+{"version":3,"names":["_AudioAPIModule","_interopRequireDefault","require","e","__esModule","default"],"sourceRoot":"../../../src","sources":["AudioAPIModule/index.ts"],"mappings":";;;;;;;;;;;AAAA,IAAAA,eAAA,GAAAC,sBAAA,CAAAC,OAAA;AAA2C,SAAAD,uBAAAE,CAAA,WAAAA,CAAA,IAAAA,CAAA,CAAAC,UAAA,GAAAD,CAAA,KAAAE,OAAA,EAAAF,CAAA","ignoreList":[]}