react-native-audio-concat 0.2.3 → 0.3.0

package/AudioConcat.podspec

@@ -1,7 +1,6 @@
 require "json"
 
 package = JSON.parse(File.read(File.join(__dir__, "package.json")))
-folly_compiler_flags = '-DFOLLY_NO_CONFIG -DFOLLY_MOBILE=1 -DFOLLY_USE_LIBCPP=1'
 
 Pod::Spec.new do |s|
   s.name         = "AudioConcat"
@@ -14,27 +13,9 @@ Pod::Spec.new do |s|
   s.platforms    = { :ios => min_ios_version_supported }
   s.source       = { :git => "https://github.com/felixchen-dev/react-native-audio-concat.git", :tag => "#{s.version}" }
 
+  s.source_files = "ios/**/*.{h,m,mm,cpp}"
+  s.private_header_files = "ios/**/*.h"
 
-  s.source_files = [
-    "ios/**/*.{swift}",
-    "ios/**/*.{m,mm}",
-    "cpp/**/*.{hpp,cpp}",
-  ]
-
-  s.pod_target_xcconfig = {
-    "HEADER_SEARCH_PATHS" => [
-      "${PODS_ROOT}/RCT-Folly",
-    ],
-    "GCC_PREPROCESSOR_DEFINITIONS" => "$(inherited) FOLLY_NO_CONFIG FOLLY_CFG_NO_COROUTINES",
-    "OTHER_CPLUSPLUSFLAGS" => folly_compiler_flags,
-  }
-
-
-  s.dependency 'React-jsi'
-  s.dependency 'React-callinvoker'
-
-  load 'nitrogen/generated/ios/AudioConcat+autolinking.rb'
-  add_nitrogen_files(s)
 
   install_modules_dependencies(s)
 end

package/README.md

@@ -6,17 +6,14 @@ Concatenate audio files and silence periods into a single audio file for React N
 
 - ✅ Concat multiple audio files with silence periods
 - ✅ Support for iOS and Android
-- ✅ High performance using [Nitro Modules](https://nitro.margelo.com/)
 - ✅ Output in M4A format
 
 ## Installation
 
 ```sh
-npm install react-native-audio-concat react-native-nitro-modules
+npm install react-native-audio-concat
 ```
 
-> **Note:** `react-native-nitro-modules` is required as this library relies on [Nitro Modules](https://nitro.margelo.com/).
-
 ### iOS
 
 ```sh
@@ -35,10 +32,10 @@ import { concatAudioFiles } from 'react-native-audio-concat';
 // Concatenate audio files with silence periods
 const data = [
   { filePath: '/path/to/audio1.m4a' },
-  { durationMs: 500 },  // 500ms silence
+  { durationMs: 500 }, // 500ms silence
   { filePath: '/path/to/audio2.m4a' },
   { durationMs: 1000 }, // 1 second silence
-  { filePath: '/path/to/audio3.m4a' }
+  { filePath: '/path/to/audio3.m4a' },
 ];
 
 const outputPath = '/path/to/merged.m4a';
@@ -72,7 +69,6 @@ Concatenates audio files and silence periods into a single output file.
 
 Check out the [example app](example/) for a complete working example.
 
-
 ## Contributing
 
 - [Development workflow](CONTRIBUTING.md#development-workflow)

package/android/build.gradle

@@ -15,79 +15,28 @@ buildscript {
   }
 }
 
-def reactNativeArchitectures() {
-  def value = rootProject.getProperties().get("reactNativeArchitectures")
-  return value ? value.split(",") : ["armeabi-v7a", "x86", "x86_64", "arm64-v8a"]
-}
 
 apply plugin: "com.android.library"
 apply plugin: "kotlin-android"
-apply from: '../nitrogen/generated/android/audioconcat+autolinking.gradle'
 
-// Note: Don't apply "com.facebook.react" plugin in library modules
-// as it triggers autolinking. Only the app module should autolink dependencies.
+apply plugin: "com.facebook.react"
 
 def getExtOrIntegerDefault(name) {
   return rootProject.ext.has(name) ? rootProject.ext.get(name) : (project.properties["AudioConcat_" + name]).toInteger()
 }
 
 android {
-  namespace "com.margelo.nitro.audioconcat"
+  namespace "com.audioconcat"
 
   compileSdkVersion getExtOrIntegerDefault("compileSdkVersion")
 
   defaultConfig {
     minSdkVersion getExtOrIntegerDefault("minSdkVersion")
     targetSdkVersion getExtOrIntegerDefault("targetSdkVersion")
-
-    externalNativeBuild {
-      cmake {
-        cppFlags "-frtti -fexceptions -Wall -fstack-protector-all"
-        arguments "-DANDROID_STL=c++_shared", "-DANDROID_SUPPORT_FLEXIBLE_PAGE_SIZES=ON"
-        abiFilters (*reactNativeArchitectures())
-
-        buildTypes {
-          debug {
-            cppFlags "-O1 -g"
-          }
-          release {
-            cppFlags "-O2"
-          }
-        }
-      }
-    }
-  }
-
-  externalNativeBuild {
-    cmake {
-      path "CMakeLists.txt"
-    }
-  }
-
-  packagingOptions {
-    excludes = [
-            "META-INF",
-            "META-INF/**",
-            "**/libc++_shared.so",
-            "**/libfbjni.so",
-            "**/libjsi.so",
-            "**/libfolly_json.so",
-            "**/libfolly_runtime.so",
-            "**/libglog.so",
-            "**/libhermes.so",
-            "**/libhermes-executor-debug.so",
-            "**/libhermes_executor.so",
-            "**/libreactnative.so",
-            "**/libreactnativejni.so",
-            "**/libturbomodulejsijni.so",
-            "**/libreact_nativemodule_core.so",
-            "**/libjscexecutor.so"
-    ]
   }
 
   buildFeatures {
     buildConfig true
-    prefab true
   }
 
   buildTypes {
@@ -125,5 +74,4 @@ def kotlin_version = getExtOrDefault("kotlinVersion")
 dependencies {
   implementation "com.facebook.react:react-android"
   implementation "org.jetbrains.kotlin:kotlin-stdlib:$kotlin_version"
-  implementation project(":react-native-nitro-modules")
 }

package/android/src/main/java/com/{margelo/nitro/audioconcat/AudioConcat.kt → audioconcat/AudioConcatModule.kt}

@@ -1,7 +1,10 @@
-package com.margelo.nitro.audioconcat
-  
-import com.facebook.proguard.annotations.DoNotStrip
-import com.margelo.nitro.core.Promise
+package com.audioconcat
+
+import com.facebook.react.bridge.ReactApplicationContext
+import com.facebook.react.bridge.Promise
+import com.facebook.react.bridge.ReadableArray
+import com.facebook.react.bridge.ReadableMap
+import com.facebook.react.module.annotations.ReactModule
 import android.media.MediaCodec
 import android.media.MediaCodecInfo
 import android.media.MediaExtractor
@@ -11,14 +14,21 @@ import java.io.File
 import java.nio.ByteBuffer
 import android.util.Log
 
-@DoNotStrip
-class AudioConcat : HybridAudioConcatSpec() {
-private data class AudioConfig(
+@ReactModule(name = AudioConcatModule.NAME)
+class AudioConcatModule(reactContext: ReactApplicationContext) :
+  NativeAudioConcatSpec(reactContext) {
+
+  private data class AudioConfig(
     val sampleRate: Int,
     val channelCount: Int,
     val bitRate: Int
   )
 
+  private sealed class AudioDataOrSilence {
+    data class AudioFile(val filePath: String) : AudioDataOrSilence()
+    data class Silence(val durationMs: Double) : AudioDataOrSilence()
+  }
+
   private fun extractAudioConfig(filePath: String): AudioConfig {
     val extractor = MediaExtractor()
     try {
@@ -112,7 +122,7 @@ private data class AudioConfig(
             audioTrackIndex = muxer.addTrack(newFormat)
             muxer.start()
             muxerStarted = true
-            Log.d("AwesomeLibrary", "Encoder started, format: $newFormat")
+            Log.d("AudioConcat", "Encoder started, format: $newFormat")
           }
           MediaCodec.INFO_TRY_AGAIN_LATER -> {
             if (!endOfStream) {
@@ -270,29 +280,54 @@ private data class AudioConfig(
     }
   }
 
-  override fun concatAudioFiles(data: Array<AudioDataOrSilence>, outputPath: String): Promise<String> {
-    return Promise.async {
-      if (data.isEmpty()) {
-        throw Exception("Data array is empty")
+  private fun parseAudioData(data: ReadableArray): List<AudioDataOrSilence> {
+    val result = mutableListOf<AudioDataOrSilence>()
+    for (i in 0 until data.size()) {
+      val item = data.getMap(i)
+      if (item != null) {
+        if (item.hasKey("filePath")) {
+          val filePath = item.getString("filePath")
+          if (filePath != null) {
+            result.add(AudioDataOrSilence.AudioFile(filePath))
+          }
+        } else if (item.hasKey("durationMs")) {
+          result.add(AudioDataOrSilence.Silence(item.getDouble("durationMs")))
+        }
       }
+    }
+    return result
+  }
 
-      Log.d("AwesomeLibrary", "Streaming merge of ${data.size} items")
-      Log.d("AwesomeLibrary", "Output: $outputPath")
+  override fun getName(): String {
+    return NAME
+  }
+
+  override fun concatAudioFiles(data: ReadableArray, outputPath: String, promise: Promise) {
+    try {
+      if (data.size() == 0) {
+        promise.reject("EMPTY_DATA", "Data array is empty")
+        return
+      }
+
+      val parsedData = parseAudioData(data)
+      Log.d("AudioConcat", "Streaming merge of ${parsedData.size} items")
+      Log.d("AudioConcat", "Output: $outputPath")
 
       // Get audio config from first audio file
       var audioConfig: AudioConfig? = null
-      for (item in data) {
-        if (item is AudioDataOrSilence.First) {
-          audioConfig = extractAudioConfig(item.value.filePath)
+      for (item in parsedData) {
+        if (item is AudioDataOrSilence.AudioFile) {
+          audioConfig = extractAudioConfig(item.filePath)
           break
         }
       }
 
       if (audioConfig == null) {
-        throw Exception("No audio files found in data array")
+        promise.reject("NO_AUDIO_FILES", "No audio files found in data array")
+        return
       }
 
-      Log.d("AwesomeLibrary", "Audio config: ${audioConfig.sampleRate}Hz, ${audioConfig.channelCount}ch, ${audioConfig.bitRate}bps")
+      Log.d("AudioConcat", "Audio config: ${audioConfig.sampleRate}Hz, ${audioConfig.channelCount}ch, ${audioConfig.bitRate}bps")
 
       // Delete existing output file
       val outputFile = File(outputPath)
@@ -310,19 +345,19 @@ private data class AudioConfig(
 
       try {
         // Process each item
-        for ((index, item) in data.withIndex()) {
+        for ((index, item) in parsedData.withIndex()) {
           when (item) {
-            is AudioDataOrSilence.First -> {
-              val filePath = item.value.filePath
-              Log.d("AwesomeLibrary", "Item $index: Streaming decode $filePath")
+            is AudioDataOrSilence.AudioFile -> {
+              val filePath = item.filePath
+              Log.d("AudioConcat", "Item $index: Streaming decode $filePath")
 
-              val isLastFile = (index == data.size - 1)
+              val isLastFile = (index == parsedData.size - 1)
               streamDecodeAudioFile(filePath, encoder, isLastFile)
             }
 
-            is AudioDataOrSilence.Second -> {
-              val durationMs = item.value.durationMs
-              Log.d("AwesomeLibrary", "Item $index: Streaming silence ${durationMs}ms")
+            is AudioDataOrSilence.Silence -> {
+              val durationMs = item.durationMs
+              Log.d("AudioConcat", "Item $index: Streaming silence ${durationMs}ms")
 
               streamEncodeSilence(
                 durationMs,
@@ -336,14 +371,21 @@ private data class AudioConfig(
 
         // Finish encoding
         encoder.finish()
-        Log.d("AwesomeLibrary", "Successfully merged audio to $outputPath")
+        Log.d("AudioConcat", "Successfully merged audio to $outputPath")
+        promise.resolve(outputPath)
 
       } catch (e: Exception) {
-        Log.e("AwesomeLibrary", "Error during streaming merge: ${e.message}", e)
-        throw e
+        Log.e("AudioConcat", "Error during streaming merge: ${e.message}", e)
+        promise.reject("MERGE_ERROR", e.message, e)
       }
 
-      outputPath
+    } catch (e: Exception) {
+      Log.e("AudioConcat", "Error parsing data: ${e.message}", e)
+      promise.reject("PARSE_ERROR", e.message, e)
     }
   }
+
+  companion object {
+    const val NAME = "AudioConcat"
+  }
 }

package/android/src/main/java/com/audioconcat/AudioConcatPackage.kt

@@ -0,0 +1,33 @@
+package com.audioconcat
+
+import com.facebook.react.BaseReactPackage
+import com.facebook.react.bridge.NativeModule
+import com.facebook.react.bridge.ReactApplicationContext
+import com.facebook.react.module.model.ReactModuleInfo
+import com.facebook.react.module.model.ReactModuleInfoProvider
+import java.util.HashMap
+
+class AudioConcatPackage : BaseReactPackage() {
+  override fun getModule(name: String, reactContext: ReactApplicationContext): NativeModule? {
+    return if (name == AudioConcatModule.NAME) {
+      AudioConcatModule(reactContext)
+    } else {
+      null
+    }
+  }
+
+  override fun getReactModuleInfoProvider(): ReactModuleInfoProvider {
+    return ReactModuleInfoProvider {
+      val moduleInfos: MutableMap<String, ReactModuleInfo> = HashMap()
+      moduleInfos[AudioConcatModule.NAME] = ReactModuleInfo(
+        AudioConcatModule.NAME,
+        AudioConcatModule.NAME,
+        false,  // canOverrideExistingModule
+        false,  // needsEagerInit
+        false,  // isCxxModule
+        true // isTurboModule
+      )
+      moduleInfos
+    }
+  }
+}

package/ios/AudioConcat.h

@@ -0,0 +1,5 @@
+#import <AudioConcatSpec/AudioConcatSpec.h>
+
+@interface AudioConcat : NSObject <NativeAudioConcatSpec>
+
+@end

package/ios/AudioConcat.mm

@@ -0,0 +1,104 @@
+#import "AudioConcat.h"
+#import <AVFoundation/AVFoundation.h>
+
+@implementation AudioConcat
+
+- (void)concatAudioFiles:(NSArray *)data
+              outputPath:(NSString *)outputPath
+                 resolve:(RCTPromiseResolveBlock)resolve
+                  reject:(RCTPromiseRejectBlock)reject
+{
+    dispatch_async(dispatch_get_global_queue(DISPATCH_QUEUE_PRIORITY_DEFAULT, 0), ^{
+        @try {
+            AVMutableComposition *composition = [AVMutableComposition composition];
+            AVMutableCompositionTrack *audioTrack = [composition addMutableTrackWithMediaType:AVMediaTypeAudio
+                                                                              preferredTrackID:kCMPersistentTrackID_Invalid];
+
+            CMTime currentTime = kCMTimeZero;
+
+            for (NSDictionary *item in data) {
+                if (item[@"filePath"]) {
+                    // Add audio file
+                    NSString *filePath = item[@"filePath"];
+                    NSURL *fileURL = [NSURL fileURLWithPath:filePath];
+
+                    AVURLAsset *asset = [AVURLAsset URLAssetWithURL:fileURL options:nil];
+                    NSArray *tracks = [asset tracksWithMediaType:AVMediaTypeAudio];
+
+                    if (tracks.count == 0) {
+                        reject(@"ERR_NO_AUDIO_TRACK", [NSString stringWithFormat:@"No audio track found in file: %@", filePath], nil);
+                        return;
+                    }
+
+                    AVAssetTrack *track = tracks[0];
+                    CMTimeRange timeRange = CMTimeRangeMake(kCMTimeZero, asset.duration);
+
+                    NSError *error = nil;
+                    [audioTrack insertTimeRange:timeRange
+                                        ofTrack:track
+                                         atTime:currentTime
+                                          error:&error];
+
+                    if (error) {
+                        reject(@"ERR_INSERT_TRACK", error.localizedDescription, error);
+                        return;
+                    }
+
+                    currentTime = CMTimeAdd(currentTime, asset.duration);
+
+                } else if (item[@"durationMs"]) {
+                    // Add silence period
+                    NSNumber *durationMs = item[@"durationMs"];
+                    double durationSeconds = [durationMs doubleValue] / 1000.0;
+                    CMTime silenceDuration = CMTimeMakeWithSeconds(durationSeconds, 600);
+
+                    currentTime = CMTimeAdd(currentTime, silenceDuration);
+                }
+            }
+
+            // Export the composition
+            NSURL *outputURL = [NSURL fileURLWithPath:outputPath];
+
+            // Remove existing file if it exists
+            [[NSFileManager defaultManager] removeItemAtURL:outputURL error:nil];
+
+            AVAssetExportSession *exportSession = [[AVAssetExportSession alloc] initWithAsset:composition
+                                                                                    presetName:AVAssetExportPresetAppleM4A];
+            exportSession.outputURL = outputURL;
+            exportSession.outputFileType = AVFileTypeAppleM4A;
+
+            [exportSession exportAsynchronouslyWithCompletionHandler:^{
+                switch (exportSession.status) {
+                    case AVAssetExportSessionStatusCompleted:
+                        resolve(outputPath);
+                        break;
+                    case AVAssetExportSessionStatusFailed:
+                        reject(@"ERR_EXPORT_FAILED", exportSession.error.localizedDescription, exportSession.error);
+                        break;
+                    case AVAssetExportSessionStatusCancelled:
+                        reject(@"ERR_EXPORT_CANCELLED", @"Export was cancelled", nil);
+                        break;
+                    default:
+                        reject(@"ERR_EXPORT_UNKNOWN", @"Unknown export error", nil);
+                        break;
+                }
+            }];
+
+        } @catch (NSException *exception) {
+            reject(@"ERR_EXCEPTION", exception.reason, nil);
+        }
+    });
+}
+
+- (std::shared_ptr<facebook::react::TurboModule>)getTurboModule:
+    (const facebook::react::ObjCTurboModule::InitParams &)params
+{
+    return std::make_shared<facebook::react::NativeAudioConcatSpecJSI>(params);
+}
+
++ (NSString *)moduleName
+{
+  return @"AudioConcat";
+}
+
+@end

package/lib/module/NativeAudioConcat.js

@@ -0,0 +1,5 @@
+"use strict";
+
+import { TurboModuleRegistry } from 'react-native';
+export default TurboModuleRegistry.getEnforcing('AudioConcat');
+//# sourceMappingURL=NativeAudioConcat.js.map

package/lib/module/NativeAudioConcat.js.map

@@ -0,0 +1 @@
+{"version":3,"names":["TurboModuleRegistry","getEnforcing"],"sourceRoot":"../../src","sources":["NativeAudioConcat.ts"],"mappings":";;AAAA,SAASA,mBAAmB,QAA0B,cAAc;AAWpE,eAAeA,mBAAmB,CAACC,YAAY,CAAO,aAAa,CAAC","ignoreList":[]}

package/lib/module/index.js

@@ -1,33 +1,7 @@
 "use strict";
 
-import { NitroModules } from 'react-native-nitro-modules';
-const AudioConcatHybridObject = NitroModules.createHybridObject('AudioConcat');
-
-/**
- * Concat audio files and silence periods into a single output file.
- *
- * @param data - Array of audio files and silence periods to merge.
- *               Each item can be either:
- *               - `{ filePath: string }` for an audio file
- *               - `{ durationMs: number }` for a silence period
- * @param outputPath - Absolute path where the merged audio file will be saved (M4A format)
- * @returns Promise that resolves with the output file path
- *
- * @example
- * ```typescript
- * const data = [
- *   { filePath: '/path/to/audio1.m4a' },
- *   { durationMs: 500 },  // 500ms silence
- *   { filePath: '/path/to/audio2.m4a' },
- *   { durationMs: 1000 }, // 1 second silence
- *   { filePath: '/path/to/audio3.m4a' }
- * ];
- * const output = '/path/to/merged.m4a';
- * const result = await concatAudioFiles(data, output);
- * console.log('concat file:', result);
- * ```
- */
+import AudioConcat from "./NativeAudioConcat.js";
 export function concatAudioFiles(data, outputPath) {
-  return AudioConcatHybridObject.concatAudioFiles(data, outputPath);
+  return AudioConcat.concatAudioFiles(data, outputPath);
 }
 //# sourceMappingURL=index.js.map

package/lib/module/index.js.map

@@ -1 +1 @@
-{"version":3,"names":["NitroModules","AudioConcatHybridObject","createHybridObject","concatAudioFiles","data","outputPath"],"sourceRoot":"../../src","sources":["index.tsx"],"mappings":";;AAAA,SAASA,YAAY,QAAQ,4BAA4B;AAGzD,MAAMC,uBAAuB,GAC3BD,YAAY,CAACE,kBAAkB,CAAc,aAAa,CAAC;;AAE7D;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA,OAAO,SAASC,gBAAgBA,CAC9BC,IAA0B,EAC1BC,UAAkB,EACD;EACjB,OAAOJ,uBAAuB,CAACE,gBAAgB,CAACC,IAAI,EAAEC,UAAU,CAAC;AACnE","ignoreList":[]}
+{"version":3,"names":["AudioConcat","concatAudioFiles","data","outputPath"],"sourceRoot":"../../src","sources":["index.tsx"],"mappings":";;AAAA,OAAOA,WAAW,MAAM,wBAAqB;AAI7C,OAAO,SAASC,gBAAgBA,CAC9BC,IAA0D,EAC1DC,UAAkB,EACD;EACjB,OAAOH,WAAW,CAACC,gBAAgB,CAACC,IAAI,EAAEC,UAAU,CAAC;AACvD","ignoreList":[]}

package/lib/typescript/src/NativeAudioConcat.d.ts

@@ -0,0 +1,12 @@
+import { type TurboModule } from 'react-native';
+export type AudioDataOrSilence = {
+    filePath: string;
+} | {
+    durationMs: number;
+};
+export interface Spec extends TurboModule {
+    concatAudioFiles(data: AudioDataOrSilence[], outputPath: string): Promise<string>;
+}
+declare const _default: Spec;
+export default _default;
+//# sourceMappingURL=NativeAudioConcat.d.ts.map

package/lib/typescript/src/NativeAudioConcat.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"NativeAudioConcat.d.ts","sourceRoot":"","sources":["../../../src/NativeAudioConcat.ts"],"names":[],"mappings":"AAAA,OAAO,EAAuB,KAAK,WAAW,EAAE,MAAM,cAAc,CAAC;AAErE,MAAM,MAAM,kBAAkB,GAAG;IAAE,QAAQ,EAAE,MAAM,CAAA;CAAE,GAAG;IAAE,UAAU,EAAE,MAAM,CAAA;CAAE,CAAC;AAE/E,MAAM,WAAW,IAAK,SAAQ,WAAW;IACvC,gBAAgB,CACd,IAAI,EAAE,kBAAkB,EAAE,EAC1B,UAAU,EAAE,MAAM,GACjB,OAAO,CAAC,MAAM,CAAC,CAAC;CACpB;;AAED,wBAAqE"}

package/lib/typescript/src/index.d.ts

@@ -1,28 +1,7 @@
-import type { AudioDataOrSilence } from './AudioConcat.nitro';
-/**
- * Concat audio files and silence periods into a single output file.
- *
- * @param data - Array of audio files and silence periods to merge.
- *               Each item can be either:
- *               - `{ filePath: string }` for an audio file
- *               - `{ durationMs: number }` for a silence period
- * @param outputPath - Absolute path where the merged audio file will be saved (M4A format)
- * @returns Promise that resolves with the output file path
- *
- * @example
- * ```typescript
- * const data = [
- *   { filePath: '/path/to/audio1.m4a' },
- *   { durationMs: 500 },  // 500ms silence
- *   { filePath: '/path/to/audio2.m4a' },
- *   { durationMs: 1000 }, // 1 second silence
- *   { filePath: '/path/to/audio3.m4a' }
- * ];
- * const output = '/path/to/merged.m4a';
- * const result = await concatAudioFiles(data, output);
- * console.log('concat file:', result);
- * ```
- */
-export declare function concatAudioFiles(data: AudioDataOrSilence[], outputPath: string): Promise<string>;
-export type { AudioDataOrSilence } from './AudioConcat.nitro';
+export type { AudioDataOrSilence } from './NativeAudioConcat';
+export declare function concatAudioFiles(data: Array<{
+    filePath: string;
+} | {
+    durationMs: number;
+}>, outputPath: string): Promise<string>;
 //# sourceMappingURL=index.d.ts.map

package/lib/typescript/src/index.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../../src/index.tsx"],"names":[],"mappings":"AACA,OAAO,KAAK,EAAe,kBAAkB,EAAE,MAAM,qBAAqB,CAAC;AAK3E;;;;;;;;;;;;;;;;;;;;;;;GAuBG;AACH,wBAAgB,gBAAgB,CAC9B,IAAI,EAAE,kBAAkB,EAAE,EAC1B,UAAU,EAAE,MAAM,GACjB,OAAO,CAAC,MAAM,CAAC,CAEjB;AAED,YAAY,EAAE,kBAAkB,EAAE,MAAM,qBAAqB,CAAC"}
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../../src/index.tsx"],"names":[],"mappings":"AAEA,YAAY,EAAE,kBAAkB,EAAE,MAAM,qBAAqB,CAAC;AAE9D,wBAAgB,gBAAgB,CAC9B,IAAI,EAAE,KAAK,CAAC;IAAE,QAAQ,EAAE,MAAM,CAAA;CAAE,GAAG;IAAE,UAAU,EAAE,MAAM,CAAA;CAAE,CAAC,EAC1D,UAAU,EAAE,MAAM,GACjB,OAAO,CAAC,MAAM,CAAC,CAEjB"}