react-native-sherpa-onnx 0.2.0 → 0.3.0

package/ios/SherpaOnnx.h

@@ -1,6 +1,17 @@
-#import <React/RCTEventEmitter.h>
-#import <SherpaOnnxSpec/SherpaOnnxSpec.h>
-
-@interface SherpaOnnx : RCTEventEmitter <NativeSherpaOnnxSpec>
-
-@end
+#import <React/RCTEventEmitter.h>
+
+// The codegen-generated header `SherpaOnnxSpec/SherpaOnnxSpec.h` is produced
+// by React Native's codegen. In some build setups (CI or a fresh checkout)
+// it may be missing until the iOS codegen step runs. Guard the import so
+// the library can still compile (useful for IDEs and quick static checks).
+#if __has_include(<SherpaOnnxSpec/SherpaOnnxSpec.h>)
+#import <SherpaOnnxSpec/SherpaOnnxSpec.h>
+#else
+// Minimal fallback to allow compilation before codegen runs.
+@protocol NativeSherpaOnnxSpec
+@end
+#endif
+
+@interface SherpaOnnx : RCTEventEmitter <NativeSherpaOnnxSpec>
+
+@end

package/ios/SherpaOnnx.mm

@@ -1,311 +1,206 @@
-/*
- * Core SherpaOnnx module helpers (paths, assets, and event registration).
- * Feature-specific methods are implemented in SherpaOnnx+STT.mm and SherpaOnnx+TTS.mm.
- */
-
-#import "SherpaOnnx.h"
-#import <React/RCTLog.h>
-
-@implementation SherpaOnnx
-
-- (NSArray<NSString *> *)supportedEvents
-{
-    return @[ @"ttsStreamChunk", @"ttsStreamEnd", @"ttsStreamError" ];
-}
-
-- (void)resolveModelPath:(NSDictionary *)config
-            withResolver:(RCTPromiseResolveBlock)resolve
-            withRejecter:(RCTPromiseRejectBlock)reject
-{
-    NSString *type = config[@"type"] ?: @"auto";
-    NSString *path = config[@"path"];
-
-    if (!path) {
-        reject(@"PATH_REQUIRED", @"Path is required", nil);
-        return;
-    }
-
-    NSError *error = nil;
-    NSString *resolvedPath = nil;
-
-    if ([type isEqualToString:@"asset"]) {
-        resolvedPath = [self resolveAssetPath:path error:&error];
-    } else if ([type isEqualToString:@"file"]) {
-        resolvedPath = [self resolveFilePath:path error:&error];
-    } else if ([type isEqualToString:@"auto"]) {
-        resolvedPath = [self resolveAutoPath:path error:&error];
-    } else {
-        NSString *errorMsg = [NSString stringWithFormat:@"Unknown path type: %@", type];
-        reject(@"INVALID_TYPE", errorMsg, nil);
-        return;
-    }
-
-    if (error) {
-        reject(@"PATH_RESOLVE_ERROR", error.localizedDescription, error);
-        return;
-    }
-
-    resolve(resolvedPath);
-}
-
-- (NSString *)resolveAssetPath:(NSString *)assetPath error:(NSError **)error
-{
-    NSFileManager *fileManager = [NSFileManager defaultManager];
-
-    // First, try to find directly in bundle (for folder references)
-    NSString *bundlePath = [[NSBundle mainBundle] pathForResource:assetPath ofType:nil];
-
-    if (bundlePath && [fileManager fileExistsAtPath:bundlePath]) {
-        return bundlePath;
-    }
-
-    // Try with directory structure (for resources in subdirectories)
-    NSArray *pathComponents = [assetPath componentsSeparatedByString:@"/"];
-    if (pathComponents.count > 1) {
-        NSString *directory = pathComponents[0];
-        for (NSInteger i = 1; i < pathComponents.count - 1; i++) {
-            directory = [directory stringByAppendingPathComponent:pathComponents[i]];
-        }
-        NSString *resourceName = pathComponents.lastObject;
-        bundlePath = [[NSBundle mainBundle] pathForResource:resourceName ofType:nil inDirectory:directory];
-
-        if (bundlePath && [fileManager fileExistsAtPath:bundlePath]) {
-            return bundlePath;
-        }
-    }
-
-    // If not found in bundle, try to copy from bundle to Documents
-    NSString *documentsPath = [NSSearchPathForDirectoriesInDomains(NSDocumentDirectory, NSUserDomainMask, YES) firstObject];
-    NSString *targetDir = [documentsPath stringByAppendingPathComponent:@"models"];
-    NSString *modelDir = [targetDir stringByAppendingPathComponent:[assetPath lastPathComponent]];
-
-    // Check if already copied
-    if ([fileManager fileExistsAtPath:modelDir]) {
-        return modelDir;
-    }
-
-    // Try to find and copy from bundle resource path
-    NSString *bundleResourcePath = [[NSBundle mainBundle] resourcePath];
-    NSString *sourcePath = [bundleResourcePath stringByAppendingPathComponent:assetPath];
-
-    if ([fileManager fileExistsAtPath:sourcePath]) {
-        NSError *copyError = nil;
-        [fileManager createDirectoryAtPath:targetDir withIntermediateDirectories:YES attributes:nil error:&copyError];
-        if (copyError) {
-            if (error) *error = copyError;
-            return nil;
-        }
-
-        // Copy recursively if it's a directory
-        BOOL isDirectory = NO;
-        [fileManager fileExistsAtPath:sourcePath isDirectory:&isDirectory];
-
-        if (isDirectory) {
-            [fileManager copyItemAtPath:sourcePath toPath:modelDir error:&copyError];
-        } else {
-            [fileManager copyItemAtPath:sourcePath toPath:modelDir error:&copyError];
-        }
-
-        if (copyError) {
-            if (error) *error = copyError;
-            return nil;
-        }
-
-        return modelDir;
-    }
-
-    if (error) {
-        *error = [NSError errorWithDomain:@"SherpaOnnx"
-                                      code:1
-                                  userInfo:@{NSLocalizedDescriptionKey: [NSString stringWithFormat:@"Asset path not found: %@", assetPath]}];
-    }
-    return nil;
-}
-
-- (NSString *)resolveFilePath:(NSString *)filePath error:(NSError **)error
-{
-    NSFileManager *fileManager = [NSFileManager defaultManager];
-    BOOL isDirectory = NO;
-    BOOL exists = [fileManager fileExistsAtPath:filePath isDirectory:&isDirectory];
-
-    if (!exists) {
-        if (error) {
-            *error = [NSError errorWithDomain:@"SherpaOnnx"
-                                          code:2
-                                      userInfo:@{NSLocalizedDescriptionKey: [NSString stringWithFormat:@"File path does not exist: %@", filePath]}];
-        }
-        return nil;
-    }
-
-    if (!isDirectory) {
-        if (error) {
-            *error = [NSError errorWithDomain:@"SherpaOnnx"
-                                          code:3
-                                      userInfo:@{NSLocalizedDescriptionKey: [NSString stringWithFormat:@"Path is not a directory: %@", filePath]}];
-        }
-        return nil;
-    }
-
-    return [filePath stringByStandardizingPath];
-}
-
-- (NSString *)resolveAutoPath:(NSString *)path error:(NSError **)error
-{
-    // Try asset first
-    NSError *assetError = nil;
-    NSString *resolvedPath = [self resolveAssetPath:path error:&assetError];
-
-    if (resolvedPath) {
-        return resolvedPath;
-    }
-
-    // If asset fails, try file system
-    NSError *fileError = nil;
-    resolvedPath = [self resolveFilePath:path error:&fileError];
-
-    if (resolvedPath) {
-        return resolvedPath;
-    }
-
-    // Both failed
-    if (error) {
-        NSString *errorMessage = [NSString stringWithFormat:@"Path not found as asset or file: %@. Asset error: %@, File error: %@",
-                                   path,
-                                   assetError.localizedDescription ?: @"Unknown",
-                                   fileError.localizedDescription ?: @"Unknown"];
-        *error = [NSError errorWithDomain:@"SherpaOnnx"
-                                      code:4
-                                  userInfo:@{NSLocalizedDescriptionKey: errorMessage}];
-    }
-    return nil;
-}
-
-- (void)testSherpaInitWithResolver:(RCTPromiseResolveBlock)resolve
-                      withRejecter:(RCTPromiseRejectBlock)reject
-{
-    @try {
-        resolve(@"Sherpa ONNX loaded!");
-    } @catch (NSException *exception) {
-        NSString *errorMsg = [NSString stringWithFormat:@"Exception during test: %@", exception.reason];
-        reject(@"TEST_ERROR", errorMsg, nil);
-    }
-}
-
-- (void)listAssetModels:(RCTPromiseResolveBlock)resolve
-          withRejecter:(RCTPromiseRejectBlock)reject
-{
-    @try {
-        NSFileManager *fileManager = [NSFileManager defaultManager];
-        NSMutableArray<NSString *> *modelFolders = [NSMutableArray array];
-
-        // Get the main bundle resource path
-        NSString *bundleResourcePath = [[NSBundle mainBundle] resourcePath];
-        NSString *modelsPath = [bundleResourcePath stringByAppendingPathComponent:@"models"];
-
-        // Check if models directory exists
-        BOOL isDirectory = NO;
-        BOOL exists = [fileManager fileExistsAtPath:modelsPath isDirectory:&isDirectory];
-
-        if (exists && isDirectory) {
-            NSError *error = nil;
-            NSArray<NSString *> *items = [fileManager contentsOfDirectoryAtPath:modelsPath error:&error];
-
-            if (error) {
-                RCTLogWarn(@"Could not list models directory: %@", error.localizedDescription);
-            } else {
-                // Filter to only include directories
-                for (NSString *item in items) {
-                    // Skip hidden files (starting with .)
-                    if ([item hasPrefix:@"."]) {
-                        continue;
-                    }
-
-                    NSString *itemPath = [modelsPath stringByAppendingPathComponent:item];
-                    BOOL itemIsDirectory = NO;
-                    [fileManager fileExistsAtPath:itemPath isDirectory:&itemIsDirectory];
-
-                    if (itemIsDirectory) {
-                        [modelFolders addObject:item];
-                    }
-                }
-            }
-        } else {
-            RCTLogWarn(@"Models directory not found at: %@", modelsPath);
-        }
-
-        NSMutableArray<NSDictionary *> *result = [NSMutableArray array];
-        for (NSString *folder in modelFolders) {
-            NSString *hint = [self inferModelHint:folder];
-            [result addObject:@{ @"folder": folder, @"hint": hint }];
-        }
-        resolve(result);
-    } @catch (NSException *exception) {
-        NSString *errorMsg = [NSString stringWithFormat:@"Exception listing asset models: %@", exception.reason];
-        reject(@"LIST_ASSETS_ERROR", errorMsg, nil);
-    }
-}
-
-// Infer a high-level model type hint from a folder name.
-- (NSString *)inferModelHint:(NSString *)folderName
-{
-    NSString *name = [folderName lowercaseString];
-    NSArray<NSString *> *sttHints = @[
-        @"zipformer",
-        @"paraformer",
-        @"nemo",
-        @"parakeet",
-        @"whisper",
-        @"wenet",
-        @"sensevoice",
-        @"sense-voice",
-        @"sense",
-        @"funasr",
-        @"transducer",
-        @"ctc",
-        @"asr"
-    ];
-    NSArray<NSString *> *ttsHints = @[
-        @"vits",
-        @"piper",
-        @"matcha",
-        @"kokoro",
-        @"kitten",
-        @"zipvoice",
-        @"melo",
-        @"coqui",
-        @"mms",
-        @"tts"
-    ];
-
-    BOOL isStt = NO;
-    for (NSString *hint in sttHints) {
-        if ([name containsString:hint]) {
-            isStt = YES;
-            break;
-        }
-    }
-
-    BOOL isTts = NO;
-    for (NSString *hint in ttsHints) {
-        if ([name containsString:hint]) {
-            isTts = YES;
-            break;
-        }
-    }
-
-    if (isStt && isTts) {
-        return @"unknown";
-    }
-
-    if (isStt) {
-        return @"stt";
-    }
-
-    if (isTts) {
-        return @"tts";
-    }
-
-    return @"unknown";
-}
-
-@end
+/**
+ * SherpaOnnx.mm
+ *
+ * Purpose: Main React Native TurboModule for SherpaOnnx. Implements resolveModelPath (delegates to
+ * SherpaOnnx+Assets.mm), extractTarBz2/computeFileSha256 via sherpa-onnx-archive-helper, capability
+ * stubs (QNN/NNAPI/XNNPACK/CoreML), and event registration. Asset/path logic lives in
+ * SherpaOnnx+Assets.mm; STT/TTS in SherpaOnnx+STT.mm and SherpaOnnx+TTS.mm.
+ */
+
+#import "SherpaOnnx.h"
+#import "SherpaOnnx+Assets.h"
+#import "sherpa-onnx-archive-helper.h"
+#import <React/RCTLog.h>
+#if __has_include("SherpaOnnx-Swift.h")
+#import "SherpaOnnx-Swift.h"
+#endif
+
+@implementation SherpaOnnx
+
++ (NSString *)moduleName
+{
+    return @"SherpaOnnx";
+}
+
+- (std::shared_ptr<facebook::react::TurboModule>)getTurboModule:
+    (const facebook::react::ObjCTurboModule::InitParams &)params
+{
+    return std::make_shared<facebook::react::NativeSherpaOnnxSpecJSI>(params);
+}
+
+- (NSArray<NSString *> *)supportedEvents
+{
+    return @[ @"ttsStreamChunk", @"ttsStreamEnd", @"ttsStreamError", @"extractTarBz2Progress" ];
+}
+
+- (void)resolveModelPath:(JS::NativeSherpaOnnx::SpecResolveModelPathConfig &)config
+                 resolve:(RCTPromiseResolveBlock)resolve
+                  reject:(RCTPromiseRejectBlock)reject
+{
+    NSString *type = config.type() ?: @"auto";
+    NSString *path = config.path();
+
+    if (!path) {
+        reject(@"PATH_REQUIRED", @"Path is required", nil);
+        return;
+    }
+
+    NSError *error = nil;
+    NSString *resolvedPath = nil;
+
+    if ([type isEqualToString:@"asset"]) {
+        resolvedPath = [self resolveAssetPath:path error:&error];
+    } else if ([type isEqualToString:@"file"]) {
+        resolvedPath = [self resolveFilePath:path error:&error];
+    } else if ([type isEqualToString:@"auto"]) {
+        resolvedPath = [self resolveAutoPath:path error:&error];
+    } else {
+        NSString *errorMsg = [NSString stringWithFormat:@"Unknown path type: %@", type];
+        reject(@"INVALID_TYPE", errorMsg, nil);
+        return;
+    }
+
+    if (error) {
+        reject(@"PATH_RESOLVE_ERROR", error.localizedDescription, error);
+        return;
+    }
+
+    resolve(resolvedPath);
+}
+
+- (void)testSherpaInit:(RCTPromiseResolveBlock)resolve
+                reject:(RCTPromiseRejectBlock)reject
+{
+    @try {
+        resolve(@"Sherpa ONNX loaded!");
+    } @catch (NSException *exception) {
+        NSString *errorMsg = [NSString stringWithFormat:@"Exception during test: %@", exception.reason];
+        reject(@"TEST_ERROR", errorMsg, nil);
+    }
+}
+
+// QNN (Qualcomm NPU) is Android-only; on iOS the build never has QNN support.
+- (void)getQnnSupport:(NSString *)modelBase64
+              resolve:(RCTPromiseResolveBlock)resolve
+               reject:(RCTPromiseRejectBlock)reject
+{
+    resolve(@{ @"providerCompiled": @NO, @"hasAccelerator": @NO, @"canInit": @NO });
+}
+
+// NNAPI is Android-only; on iOS we always return no support.
+- (void)getNnapiSupport:(NSString *)modelBase64
+                resolve:(RCTPromiseResolveBlock)resolve
+                 reject:(RCTPromiseRejectBlock)reject
+{
+    resolve(@{ @"providerCompiled": @NO, @"hasAccelerator": @NO, @"canInit": @NO });
+}
+
+// XNNPACK support: stub on iOS (could be extended to check ORT providers and session init).
+- (void)getXnnpackSupport:(NSString *)modelBase64
+                  resolve:(RCTPromiseResolveBlock)resolve
+                   reject:(RCTPromiseRejectBlock)reject
+{
+    resolve(@{ @"providerCompiled": @NO, @"hasAccelerator": @NO, @"canInit": @NO });
+}
+
+// Core ML support (iOS): providerCompiled = true (Core ML on iOS 11+), hasAccelerator = Apple Neural Engine, canInit = session test (stub false unless ORT linked).
+- (void)getCoreMlSupport:(NSString *)modelBase64
+                 resolve:(RCTPromiseResolveBlock)resolve
+                  reject:(RCTPromiseRejectBlock)reject
+{
+    BOOL hasANE = NO;
+#if __has_include("SherpaOnnx-Swift.h")
+    if ([SherpaOnnxCoreMLHelper respondsToSelector:@selector(hasAppleNeuralEngine)]) {
+        hasANE = [SherpaOnnxCoreMLHelper hasAppleNeuralEngine];
+    }
+#endif
+    resolve(@{
+        @"providerCompiled": @YES,  // Core ML always present on iOS 11+
+        @"hasAccelerator": hasANE ? @YES : @NO,
+        @"canInit": @NO,  // Would require ORT session with CoreML EP; not implemented here
+    });
+}
+
+- (void)extractTarBz2:(NSString *)sourcePath
+           targetPath:(NSString *)targetPath
+                force:(BOOL)force
+         resolve:(RCTPromiseResolveBlock)resolve
+         reject:(RCTPromiseRejectBlock)reject
+{
+    SherpaOnnxArchiveHelper *helper = [SherpaOnnxArchiveHelper new];
+    NSDictionary *result = [helper extractTarBz2:sourcePath
+                                     targetPath:targetPath
+                                          force:force
+                                       progress:^(long long bytes, long long totalBytes, double percent) {
+        [self sendEventWithName:@"extractTarBz2Progress"
+                           body:@{ @"sourcePath": sourcePath,
+                                   @"bytes": @(bytes),
+                                   @"totalBytes": @(totalBytes),
+                                   @"percent": @(percent) }];
+    }];
+    resolve(result);
+}
+
+- (void)cancelExtractTarBz2:(RCTPromiseResolveBlock)resolve
+               reject:(RCTPromiseRejectBlock)reject
+{
+    [SherpaOnnxArchiveHelper cancelExtractTarBz2];
+    resolve(nil);
+}
+
+- (void)computeFileSha256:(NSString *)filePath
+             resolve:(RCTPromiseResolveBlock)resolve
+             reject:(RCTPromiseRejectBlock)reject
+{
+    SherpaOnnxArchiveHelper *helper = [SherpaOnnxArchiveHelper new];
+    NSError *error = nil;
+    NSString *digest = [helper computeFileSha256:filePath error:&error];
+    if (error || !digest) {
+        reject(@"CHECKSUM_ERROR", error.localizedDescription ?: @"Failed to compute SHA-256", error);
+        return;
+    }
+    resolve(digest);
+}
+
+- (void)getAssetPackPath:(NSString *)packName
+                 resolve:(RCTPromiseResolveBlock)resolve
+                  reject:(RCTPromiseRejectBlock)reject
+{
+    // Play Asset Delivery is Android-only; on iOS there is no asset pack path.
+    resolve([NSNull null]);
+}
+
+- (void)convertAudioToFormat:(NSString *)inputPath
+                 outputPath:(NSString *)outputPath
+                     format:(NSString *)format
+         outputSampleRateHz:(NSNumber *)outputSampleRateHz
+                    resolve:(RCTPromiseResolveBlock)resolve
+                     reject:(RCTPromiseRejectBlock)reject
+{
+    reject(@"UNSUPPORTED", @"convertAudioToFormat is not implemented on iOS", nil);
+}
+
+- (void)convertAudioToWav16k:(NSString *)inputPath
+                 outputPath:(NSString *)outputPath
+                    resolve:(RCTPromiseResolveBlock)resolve
+                     reject:(RCTPromiseRejectBlock)reject
+{
+    reject(@"UNSUPPORTED", @"convertAudioToWav16k is not implemented on iOS", nil);
+}
+
+- (void)getAvailableProviders:(RCTPromiseResolveBlock)resolve
+                      reject:(RCTPromiseRejectBlock)reject
+{
+    @try {
+        NSMutableArray<NSString *> *providers = [NSMutableArray arrayWithObject:@"CPUExecutionProvider"];
+#if __has_include(<onnxruntime/coreml_provider_factory.h>)
+        [providers addObject:@"CoreMLExecutionProvider"];
+#endif
+        resolve(providers);
+    } @catch (NSException *exception) {
+        NSString *errorMsg = [NSString stringWithFormat:@"Failed to get providers: %@", exception.reason];
+        reject(@"PROVIDERS_ERROR", errorMsg, nil);
+    }
+}
+
+@end

package/ios/SherpaOnnx.xcconfig

@@ -1,19 +1,19 @@
-// SherpaOnnx build configuration
-// This file handles the conditional linking of sherpa-onnx static library
-// based on the target platform (device vs simulator)
-//
-// SHERPA_ONNX_FRAMEWORK_PATH should be set by the Podfile or build system
-// to the absolute path of the sherpa_onnx.xcframework directory
-
-// Define the library directory based on SDK
-// For device builds (iphoneos)
-SHERPA_ONNX_LIB_DIR[sdk=iphoneos*] = $(SHERPA_ONNX_FRAMEWORK_PATH)/ios-arm64
-// For simulator builds (iphonesimulator) 
-SHERPA_ONNX_LIB_DIR[sdk=iphonesimulator*] = $(SHERPA_ONNX_FRAMEWORK_PATH)/ios-arm64_x86_64-simulator
-
-// Add the library search path
-LIBRARY_SEARCH_PATHS = $(inherited) "$(SHERPA_ONNX_LIB_DIR)"
-
-// Force load the static library to ensure all symbols are included
-// This is necessary because the library symbols are called from Objective-C++
-OTHER_LDFLAGS = $(inherited) -force_load "$(SHERPA_ONNX_LIB_DIR)/libsherpa-onnx.a"
+// SherpaOnnx build configuration
+// This file handles the conditional linking of sherpa-onnx static library
+// based on the target platform (device vs simulator)
+//
+// SHERPA_ONNX_FRAMEWORK_PATH should be set by the Podfile or build system
+// to the absolute path of the sherpa_onnx.xcframework directory
+
+// Define the library directory based on SDK
+// For device builds (iphoneos)
+SHERPA_ONNX_LIB_DIR[sdk=iphoneos*] = $(SHERPA_ONNX_FRAMEWORK_PATH)/ios-arm64
+// For simulator builds (iphonesimulator) 
+SHERPA_ONNX_LIB_DIR[sdk=iphonesimulator*] = $(SHERPA_ONNX_FRAMEWORK_PATH)/ios-arm64_x86_64-simulator
+
+// Add the library search path
+LIBRARY_SEARCH_PATHS = $(inherited) "$(SHERPA_ONNX_LIB_DIR)"
+
+// Force load the static library to ensure all symbols are included
+// This is necessary because the library symbols are called from Objective-C++
+OTHER_LDFLAGS = $(inherited) -force_load "$(SHERPA_ONNX_LIB_DIR)/libsherpa-onnx.a"

package/ios/SherpaOnnxCoreMLHelper.swift

@@ -0,0 +1,24 @@
+/*
+ * Core ML / Apple Neural Engine detection for getCoreMlSupport (AccelerationSupport).
+ * Used only on iOS.
+ */
+
+import Foundation
+import CoreML
+
+@objc(SherpaOnnxCoreMLHelper)
+public class SherpaOnnxCoreMLHelper: NSObject {
+
+    /// True if the device reports Apple Neural Engine in Core ML compute devices (iOS 17+).
+    @objc public static func hasAppleNeuralEngine() -> Bool {
+        if #available(iOS 17.0, *) {
+            for device in MLModel.availableComputeDevices {
+                let typeName = String(describing: type(of: device))
+                if typeName.contains("NeuralEngine") {
+                    return true
+                }
+            }
+        }
+        return false
+    }
+}

package/ios/archive/sherpa-onnx-archive-helper.h

@@ -0,0 +1,21 @@
+#import <Foundation/Foundation.h>
+
+NS_ASSUME_NONNULL_BEGIN
+
+@interface SherpaOnnxArchiveHelper : NSObject
+
+typedef void (^SherpaOnnxArchiveProgressBlock)(long long bytes, long long totalBytes, double percent);
+
+- (NSDictionary *)extractTarBz2:(NSString *)sourcePath
+                     targetPath:(NSString *)targetPath
+                          force:(BOOL)force
+                       progress:(nullable SherpaOnnxArchiveProgressBlock)progress;
+
+- (nullable NSString *)computeFileSha256:(NSString *)filePath
+                                   error:(NSError * _Nullable * _Nullable)error;
+
++ (void)cancelExtractTarBz2;
+
+@end
+
+NS_ASSUME_NONNULL_END