@capawesome/capacitor-exif 0.0.1

package/ios/Plugin/Classes/Options/WriteExifOptions.swift

@@ -0,0 +1,49 @@
+import Foundation
+import Capacitor
+
+@objc public class WriteExifOptions: NSObject {
+    let dateTimeOriginal: String?
+    let exposureTime: Double?
+    let fNumber: Double?
+    let flash: Bool?
+    let focalLength: Double?
+    let gpsAltitude: Double?
+    let gpsLatitude: Double?
+    let gpsLongitude: Double?
+    let iso: Int?
+    let lensModel: String?
+    let make: String?
+    let model: String?
+    let orientation: Int?
+    let software: String?
+    let url: URL
+
+    init(_ call: CAPPluginCall) throws {
+        let tags = try WriteExifOptions.getTagsFromCall(call)
+        self.dateTimeOriginal = tags["dateTimeOriginal"] as? String
+        self.exposureTime = (tags["exposureTime"] as? NSNumber)?.doubleValue
+        self.fNumber = (tags["fNumber"] as? NSNumber)?.doubleValue
+        self.flash = tags["flash"] as? Bool
+        self.focalLength = (tags["focalLength"] as? NSNumber)?.doubleValue
+        self.gpsAltitude = (tags["gpsAltitude"] as? NSNumber)?.doubleValue
+        self.gpsLatitude = (tags["gpsLatitude"] as? NSNumber)?.doubleValue
+        self.gpsLongitude = (tags["gpsLongitude"] as? NSNumber)?.doubleValue
+        self.iso = (tags["iso"] as? NSNumber)?.intValue
+        self.lensModel = tags["lensModel"] as? String
+        self.make = tags["make"] as? String
+        self.model = tags["model"] as? String
+        self.orientation = (tags["orientation"] as? NSNumber)?.intValue
+        self.software = tags["software"] as? String
+        self.url = try ReadExifOptions.getUrlFromCall(call)
+        if (gpsLatitude == nil) != (gpsLongitude == nil) {
+            throw CustomError.gpsCoordinatesIncomplete
+        }
+    }
+
+    private static func getTagsFromCall(_ call: CAPPluginCall) throws -> JSObject {
+        guard let tags = call.getObject("tags") else {
+            throw CustomError.tagsMissing
+        }
+        return tags
+    }
+}

package/ios/Plugin/Classes/Results/ReadExifResult.swift

@@ -0,0 +1,75 @@
+import Foundation
+import Capacitor
+import ImageIO
+
+@objc public class ReadExifResult: NSObject, Result {
+    let properties: [String: Any]
+
+    init(properties: [String: Any]) {
+        self.properties = properties
+    }
+
+    // swiftlint:disable:next cyclomatic_complexity function_body_length
+    @objc public func toJSObject() -> AnyObject {
+        let exif = properties[kCGImagePropertyExifDictionary as String] as? [String: Any] ?? [:]
+        let gps = properties[kCGImagePropertyGPSDictionary as String] as? [String: Any] ?? [:]
+        let tiff = properties[kCGImagePropertyTIFFDictionary as String] as? [String: Any] ?? [:]
+        var tags = JSObject()
+        if let dateTimeOriginal = exif[kCGImagePropertyExifDateTimeOriginal as String] as? String {
+            tags["dateTimeOriginal"] = dateTimeOriginal
+        }
+        if let exposureTime = exif[kCGImagePropertyExifExposureTime as String] as? NSNumber {
+            tags["exposureTime"] = exposureTime.doubleValue
+        }
+        if let fNumber = exif[kCGImagePropertyExifFNumber as String] as? NSNumber {
+            tags["fNumber"] = fNumber.doubleValue
+        }
+        if let flash = exif[kCGImagePropertyExifFlash as String] as? NSNumber {
+            tags["flash"] = (flash.intValue & 1) == 1
+        }
+        if let focalLength = exif[kCGImagePropertyExifFocalLength as String] as? NSNumber {
+            tags["focalLength"] = focalLength.doubleValue
+        }
+        if let gpsAltitude = gps[kCGImagePropertyGPSAltitude as String] as? NSNumber {
+            let gpsAltitudeRef = gps[kCGImagePropertyGPSAltitudeRef as String] as? NSNumber
+            tags["gpsAltitude"] = gpsAltitudeRef?.intValue == 1 ? -gpsAltitude.doubleValue : gpsAltitude.doubleValue
+        }
+        if let gpsLatitude = gps[kCGImagePropertyGPSLatitude as String] as? NSNumber {
+            let gpsLatitudeRef = gps[kCGImagePropertyGPSLatitudeRef as String] as? String
+            tags["gpsLatitude"] = gpsLatitudeRef == "S" ? -gpsLatitude.doubleValue : gpsLatitude.doubleValue
+        }
+        if let gpsLongitude = gps[kCGImagePropertyGPSLongitude as String] as? NSNumber {
+            let gpsLongitudeRef = gps[kCGImagePropertyGPSLongitudeRef as String] as? String
+            tags["gpsLongitude"] = gpsLongitudeRef == "W" ? -gpsLongitude.doubleValue : gpsLongitude.doubleValue
+        }
+        if let iso = (exif[kCGImagePropertyExifISOSpeedRatings as String] as? [Any])?.first as? NSNumber {
+            tags["iso"] = iso.intValue
+        }
+        if let lensModel = exif[kCGImagePropertyExifLensModel as String] as? String {
+            tags["lensModel"] = lensModel
+        }
+        if let make = tiff[kCGImagePropertyTIFFMake as String] as? String {
+            tags["make"] = make
+        }
+        if let model = tiff[kCGImagePropertyTIFFModel as String] as? String {
+            tags["model"] = model
+        }
+        if let orientation = properties[kCGImagePropertyOrientation as String] as? NSNumber {
+            tags["orientation"] = orientation.intValue
+        } else if let orientation = tiff[kCGImagePropertyTIFFOrientation as String] as? NSNumber {
+            tags["orientation"] = orientation.intValue
+        }
+        if let pixelHeight = properties[kCGImagePropertyPixelHeight as String] as? NSNumber {
+            tags["pixelHeight"] = pixelHeight.intValue
+        }
+        if let pixelWidth = properties[kCGImagePropertyPixelWidth as String] as? NSNumber {
+            tags["pixelWidth"] = pixelWidth.intValue
+        }
+        if let software = tiff[kCGImagePropertyTIFFSoftware as String] as? String {
+            tags["software"] = software
+        }
+        var result = JSObject()
+        result["tags"] = tags
+        return result as AnyObject
+    }
+}

package/ios/Plugin/Enums/CustomError.swift

@@ -0,0 +1,54 @@
+import Foundation
+
+enum CustomError: Error {
+    case fileNotFound
+    case gpsCoordinatesIncomplete
+    case pathMissing
+    case readFailed
+    case tagsMissing
+    case unsupportedFormat
+    case writeFailed
+
+    var code: String? {
+        switch self {
+        case .fileNotFound:
+            return "FILE_NOT_FOUND"
+        case .gpsCoordinatesIncomplete:
+            return nil
+        case .pathMissing:
+            return nil
+        case .readFailed:
+            return "READ_FAILED"
+        case .tagsMissing:
+            return nil
+        case .unsupportedFormat:
+            return "UNSUPPORTED_FORMAT"
+        case .writeFailed:
+            return "WRITE_FAILED"
+        }
+    }
+}
+
+extension CustomError: LocalizedError {
+    public var errorDescription: String? {
+        switch self {
+        case .fileNotFound:
+            return NSLocalizedString("The file was not found at the provided path.", comment: "fileNotFound")
+        case .gpsCoordinatesIncomplete:
+            return NSLocalizedString("gpsLatitude and gpsLongitude must be provided together.", comment: "gpsCoordinatesIncomplete")
+        case .pathMissing:
+            return NSLocalizedString("path must be provided.", comment: "pathMissing")
+        case .readFailed:
+            return NSLocalizedString("The EXIF metadata could not be read from the file.", comment: "readFailed")
+        case .tagsMissing:
+            return NSLocalizedString("tags must be provided.", comment: "tagsMissing")
+        case .unsupportedFormat:
+            return NSLocalizedString(
+                "The file format does not support writing or removing EXIF metadata on this platform.",
+                comment: "unsupportedFormat"
+            )
+        case .writeFailed:
+            return NSLocalizedString("The EXIF metadata could not be written to the file.", comment: "writeFailed")
+        }
+    }
+}

package/ios/Plugin/Exif.swift

@@ -0,0 +1,219 @@
+import Foundation
+import Capacitor
+import ImageIO
+import UniformTypeIdentifiers
+
+@objc public class Exif: NSObject {
+    private static let exifExNamespace = "http://cipa.jp/exif/1.0/"
+    private static let exifExPrefix = "exifEX"
+
+    private let plugin: ExifPlugin
+
+    init(plugin: ExifPlugin) {
+        self.plugin = plugin
+    }
+
+    @objc public func readExif(_ options: ReadExifOptions, completion: @escaping (ReadExifResult?, Error?) -> Void) {
+        guard FileManager.default.fileExists(atPath: options.url.path) else {
+            completion(nil, CustomError.fileNotFound)
+            return
+        }
+        guard let source = CGImageSourceCreateWithURL(options.url as CFURL, nil),
+              let properties = CGImageSourceCopyPropertiesAtIndex(source, 0, nil) as? [String: Any] else {
+            completion(nil, CustomError.readFailed)
+            return
+        }
+        completion(ReadExifResult(properties: properties), nil)
+    }
+
+    @objc public func removeExif(_ options: RemoveExifOptions, completion: @escaping (Error?) -> Void) {
+        guard FileManager.default.fileExists(atPath: options.url.path) else {
+            completion(CustomError.fileNotFound)
+            return
+        }
+        guard let source = CGImageSourceCreateWithURL(options.url as CFURL, nil) else {
+            completion(CustomError.readFailed)
+            return
+        }
+        guard isWritableFormat(source) else {
+            completion(CustomError.unsupportedFormat)
+            return
+        }
+        let metadata = CGImageMetadataCreateMutable()
+        if options.keepOrientation, let orientation = getOrientation(of: source) {
+            setValue(metadata, kCGImagePropertyTIFFDictionary, kCGImagePropertyTIFFOrientation, orientation as CFNumber)
+        } else if isHeif(source) {
+            // HEIF files ignore an empty replacement metadata, so the orientation is reset to the default value instead.
+            setValue(metadata, kCGImagePropertyTIFFDictionary, kCGImagePropertyTIFFOrientation, 1 as CFNumber)
+        }
+        let destinationOptions: [CFString: Any] = [
+            kCGImageDestinationMetadata: metadata,
+            kCGImageMetadataShouldExcludeGPS: true,
+            kCGImageMetadataShouldExcludeXMP: true
+        ]
+        do {
+            try replaceImage(at: options.url, source: source, options: destinationOptions)
+            completion(nil)
+        } catch {
+            completion(error)
+        }
+    }
+
+    @objc public func writeExif(_ options: WriteExifOptions, completion: @escaping (Error?) -> Void) {
+        guard FileManager.default.fileExists(atPath: options.url.path) else {
+            completion(CustomError.fileNotFound)
+            return
+        }
+        guard let source = CGImageSourceCreateWithURL(options.url as CFURL, nil) else {
+            completion(CustomError.readFailed)
+            return
+        }
+        guard isWritableFormat(source) else {
+            completion(CustomError.unsupportedFormat)
+            return
+        }
+        var destinationOptions: [CFString: Any] = [:]
+        if isHeif(source) {
+            // HEIF files ignore merged metadata, so the source metadata is copied and replaced as a whole instead.
+            let metadata = createMutableMetadataCopy(of: source)
+            applyTags(options, to: metadata)
+            destinationOptions[kCGImageDestinationMetadata] = metadata
+        } else {
+            let metadata = CGImageMetadataCreateMutable()
+            applyTags(options, to: metadata)
+            destinationOptions[kCGImageDestinationMetadata] = metadata
+            destinationOptions[kCGImageDestinationMergeMetadata] = true
+        }
+        do {
+            try replaceImage(at: options.url, source: source, options: destinationOptions)
+            completion(nil)
+        } catch {
+            completion(error)
+        }
+    }
+
+    // swiftlint:disable:next cyclomatic_complexity
+    private func applyTags(_ options: WriteExifOptions, to metadata: CGMutableImageMetadata) {
+        if let dateTimeOriginal = options.dateTimeOriginal {
+            setValue(metadata, kCGImagePropertyExifDictionary, kCGImagePropertyExifDateTimeOriginal, dateTimeOriginal as CFString)
+        }
+        if let exposureTime = options.exposureTime {
+            setValue(metadata, kCGImagePropertyExifDictionary, kCGImagePropertyExifExposureTime, convertDoubleToRational(exposureTime) as CFString)
+        }
+        if let fNumber = options.fNumber {
+            setValue(metadata, kCGImagePropertyExifDictionary, kCGImagePropertyExifFNumber, convertDoubleToRational(fNumber) as CFString)
+        }
+        if let flash = options.flash {
+            setValue(metadata, kCGImagePropertyExifDictionary, kCGImagePropertyExifFlash, (flash ? 1 : 0) as CFNumber)
+        }
+        if let focalLength = options.focalLength {
+            setValue(metadata, kCGImagePropertyExifDictionary, kCGImagePropertyExifFocalLength, convertDoubleToRational(focalLength) as CFString)
+        }
+        if let gpsAltitude = options.gpsAltitude {
+            setValue(metadata, kCGImagePropertyGPSDictionary, kCGImagePropertyGPSAltitude, convertDoubleToRational(abs(gpsAltitude)) as CFString)
+            setValue(metadata, kCGImagePropertyGPSDictionary, kCGImagePropertyGPSAltitudeRef, (gpsAltitude < 0 ? 1 : 0) as CFNumber)
+        }
+        if let gpsLatitude = options.gpsLatitude, let gpsLongitude = options.gpsLongitude {
+            setValue(metadata, kCGImagePropertyGPSDictionary, kCGImagePropertyGPSLatitude, abs(gpsLatitude) as CFNumber)
+            setValue(metadata, kCGImagePropertyGPSDictionary, kCGImagePropertyGPSLatitudeRef, (gpsLatitude < 0 ? "S" : "N") as CFString)
+            setValue(metadata, kCGImagePropertyGPSDictionary, kCGImagePropertyGPSLongitude, abs(gpsLongitude) as CFNumber)
+            setValue(metadata, kCGImagePropertyGPSDictionary, kCGImagePropertyGPSLongitudeRef, (gpsLongitude < 0 ? "W" : "E") as CFString)
+        }
+        if let iso = options.iso {
+            // The ISO tag cannot be overwritten via the `exif` namespace, so the `exifEX` namespace is used as well.
+            _ = CGImageMetadataRemoveTagWithPath(metadata, nil, "exif:ISOSpeedRatings" as CFString)
+            setValue(metadata, kCGImagePropertyExifDictionary, kCGImagePropertyExifISOSpeedRatings, [iso] as CFArray)
+            setPhotographicSensitivity(iso, to: metadata)
+        }
+        if let lensModel = options.lensModel {
+            setValue(metadata, kCGImagePropertyExifDictionary, kCGImagePropertyExifLensModel, lensModel as CFString)
+        }
+        if let make = options.make {
+            setValue(metadata, kCGImagePropertyTIFFDictionary, kCGImagePropertyTIFFMake, make as CFString)
+        }
+        if let model = options.model {
+            setValue(metadata, kCGImagePropertyTIFFDictionary, kCGImagePropertyTIFFModel, model as CFString)
+        }
+        if let orientation = options.orientation {
+            setValue(metadata, kCGImagePropertyTIFFDictionary, kCGImagePropertyTIFFOrientation, orientation as CFNumber)
+        }
+        if let software = options.software {
+            setValue(metadata, kCGImagePropertyTIFFDictionary, kCGImagePropertyTIFFSoftware, software as CFString)
+        }
+    }
+
+    private func convertDoubleToRational(_ value: Double) -> String {
+        return "\(Int((value * 1000).rounded()))/1000"
+    }
+
+    private func createMutableMetadataCopy(of source: CGImageSource) -> CGMutableImageMetadata {
+        if let metadata = CGImageSourceCopyMetadataAtIndex(source, 0, nil), let copy = CGImageMetadataCreateMutableCopy(metadata) {
+            return copy
+        }
+        return CGImageMetadataCreateMutable()
+    }
+
+    private func getOrientation(of source: CGImageSource) -> Int? {
+        guard let properties = CGImageSourceCopyPropertiesAtIndex(source, 0, nil) as? [String: Any] else {
+            return nil
+        }
+        if let orientation = properties[kCGImagePropertyOrientation as String] as? NSNumber {
+            return orientation.intValue
+        }
+        let tiff = properties[kCGImagePropertyTIFFDictionary as String] as? [String: Any]
+        if let orientation = tiff?[kCGImagePropertyTIFFOrientation as String] as? NSNumber {
+            return orientation.intValue
+        }
+        return nil
+    }
+
+    private func getUTType(of source: CGImageSource) -> UTType? {
+        guard let type = CGImageSourceGetType(source) else {
+            return nil
+        }
+        return UTType(type as String)
+    }
+
+    private func isHeif(_ source: CGImageSource) -> Bool {
+        guard let utType = getUTType(of: source) else {
+            return false
+        }
+        return utType.conforms(to: .heic) || utType.conforms(to: .heif)
+    }
+
+    private func isWritableFormat(_ source: CGImageSource) -> Bool {
+        guard let utType = getUTType(of: source) else {
+            return false
+        }
+        return utType.conforms(to: .jpeg) || utType.conforms(to: .heic) || utType.conforms(to: .heif)
+    }
+
+    private func replaceImage(at url: URL, source: CGImageSource, options: [CFString: Any]) throws {
+        guard let type = CGImageSourceGetType(source) else {
+            throw CustomError.unsupportedFormat
+        }
+        let temporaryUrl = url.deletingLastPathComponent().appendingPathComponent(UUID().uuidString)
+        guard let destination = CGImageDestinationCreateWithURL(temporaryUrl as CFURL, type, 1, nil) else {
+            throw CustomError.writeFailed
+        }
+        guard CGImageDestinationCopyImageSource(destination, source, options as CFDictionary, nil) else {
+            try? FileManager.default.removeItem(at: temporaryUrl)
+            throw CustomError.writeFailed
+        }
+        _ = try FileManager.default.replaceItemAt(url, withItemAt: temporaryUrl)
+    }
+
+    private func setPhotographicSensitivity(_ iso: Int, to metadata: CGMutableImageMetadata) {
+        let namespace = Exif.exifExNamespace as CFString
+        let prefix = Exif.exifExPrefix as CFString
+        _ = CGImageMetadataRegisterNamespaceForPrefix(metadata, namespace, prefix, nil)
+        guard let tag = CGImageMetadataTagCreate(namespace, prefix, "PhotographicSensitivity" as CFString, .string, String(iso) as CFString) else {
+            return
+        }
+        _ = CGImageMetadataSetTagWithPath(metadata, nil, "exifEX:PhotographicSensitivity" as CFString, tag)
+    }
+
+    private func setValue(_ metadata: CGMutableImageMetadata, _ dictionary: CFString, _ property: CFString, _ value: CFTypeRef) {
+        _ = CGImageMetadataSetValueMatchingImageProperty(metadata, dictionary, property, value)
+    }
+}

package/ios/Plugin/ExifPlugin.swift

@@ -0,0 +1,83 @@
+import Foundation
+import Capacitor
+
+@objc(ExifPlugin)
+public class ExifPlugin: CAPPlugin, CAPBridgedPlugin {
+    public let identifier = "ExifPlugin"
+    public let jsName = "Exif"
+    public let pluginMethods: [CAPPluginMethod] = [
+        CAPPluginMethod(name: "readExif", returnType: CAPPluginReturnPromise),
+        CAPPluginMethod(name: "removeExif", returnType: CAPPluginReturnPromise),
+        CAPPluginMethod(name: "writeExif", returnType: CAPPluginReturnPromise)
+    ]
+    public static let tag = "ExifPlugin"
+
+    private var implementation: Exif?
+
+    override public func load() {
+        self.implementation = Exif(plugin: self)
+    }
+
+    @objc func readExif(_ call: CAPPluginCall) {
+        do {
+            let options = try ReadExifOptions(call)
+            implementation?.readExif(options) { result, error in
+                if let error = error {
+                    self.rejectCall(call, error)
+                    return
+                }
+                self.resolveCall(call, result)
+            }
+        } catch {
+            rejectCall(call, error)
+        }
+    }
+
+    @objc func removeExif(_ call: CAPPluginCall) {
+        do {
+            let options = try RemoveExifOptions(call)
+            implementation?.removeExif(options) { error in
+                if let error = error {
+                    self.rejectCall(call, error)
+                    return
+                }
+                self.resolveCall(call)
+            }
+        } catch {
+            rejectCall(call, error)
+        }
+    }
+
+    @objc func writeExif(_ call: CAPPluginCall) {
+        do {
+            let options = try WriteExifOptions(call)
+            implementation?.writeExif(options) { error in
+                if let error = error {
+                    self.rejectCall(call, error)
+                    return
+                }
+                self.resolveCall(call)
+            }
+        } catch {
+            rejectCall(call, error)
+        }
+    }
+
+    private func rejectCall(_ call: CAPPluginCall, _ error: Error) {
+        CAPLog.print("[", ExifPlugin.tag, "] ", error)
+        let code = (error as? CustomError)?.code
+        call.reject(error.localizedDescription, code)
+    }
+
+    private func resolveCall(_ call: CAPPluginCall) {
+        call.resolve()
+    }
+
+    private func resolveCall(_ call: CAPPluginCall, _ result: Result?) {
+        if let result = result?.toJSObject() as? JSObject {
+            call.resolve(result)
+        } else {
+            call.resolve()
+        }
+    }
+}

package/ios/Plugin/Info.plist

@@ -0,0 +1,24 @@
+<?xml version="1.0" encoding="UTF-8"?>
+<!DOCTYPE plist PUBLIC "-//Apple//DTD PLIST 1.0//EN" "http://www.apple.com/DTDs/PropertyList-1.0.dtd">
+<plist version="1.0">
+<dict>
+	<key>CFBundleDevelopmentRegion</key>
+	<string>$(DEVELOPMENT_LANGUAGE)</string>
+	<key>CFBundleExecutable</key>
+	<string>$(EXECUTABLE_NAME)</string>
+	<key>CFBundleIdentifier</key>
+	<string>$(PRODUCT_BUNDLE_IDENTIFIER)</string>
+	<key>CFBundleInfoDictionaryVersion</key>
+	<string>6.0</string>
+	<key>CFBundleName</key>
+	<string>$(PRODUCT_NAME)</string>
+	<key>CFBundlePackageType</key>
+	<string>FMWK</string>
+	<key>CFBundleShortVersionString</key>
+	<string>1.0</string>
+	<key>CFBundleVersion</key>
+	<string>$(CURRENT_PROJECT_VERSION)</string>
+	<key>NSPrincipalClass</key>
+	<string></string>
+</dict>
+</plist>

package/ios/Plugin/Protocols/Result.swift

@@ -0,0 +1,5 @@
+import Capacitor
+
+@objc public protocol Result {
+    @objc func toJSObject() -> AnyObject
+}

package/package.json

@@ -0,0 +1,97 @@
+{
+  "name": "@capawesome/capacitor-exif",
+  "version": "0.0.1",
+  "description": "Capacitor plugin to read, write and remove EXIF metadata from image files.",
+  "main": "dist/plugin.cjs.js",
+  "module": "dist/esm/index.js",
+  "types": "dist/esm/index.d.ts",
+  "unpkg": "dist/plugin.js",
+  "files": [
+    "android/src/main/",
+    "android/build.gradle",
+    "dist/",
+    "ios/Plugin/",
+    "CapawesomeCapacitorExif.podspec",
+    "Package.swift"
+  ],
+  "author": "Robin Genz <mail@robingenz.dev>",
+  "license": "MIT",
+  "repository": {
+    "type": "git",
+    "url": "git+https://github.com/capawesome-team/capacitor-plugins.git"
+  },
+  "bugs": {
+    "url": "https://github.com/capawesome-team/capacitor-plugins/issues"
+  },
+  "funding": [
+    {
+      "type": "github",
+      "url": "https://github.com/sponsors/capawesome-team/"
+    },
+    {
+      "type": "opencollective",
+      "url": "https://opencollective.com/capawesome"
+    }
+  ],
+  "homepage": "https://capawesome.io/docs/sdks/capacitor/exif/",
+  "keywords": [
+    "capacitor",
+    "plugin",
+    "native",
+    "exif",
+    "metadata",
+    "gps",
+    "privacy",
+    "heic",
+    "jpeg"
+  ],
+  "scripts": {
+    "verify": "npm run verify:ios && npm run verify:android && npm run verify:web",
+    "verify:ios": "cd ios && pod install && xcodebuild -workspace Plugin.xcworkspace -scheme Plugin -destination generic/platform=iOS && cd ..",
+    "verify:android": "cd android && ./gradlew clean build test && cd ..",
+    "verify:web": "npm run build",
+    "lint": "npm run eslint && npm run prettier -- --check && npm run swiftlint -- lint",
+    "fmt": "npm run eslint -- --fix && npm run prettier -- --write && npm run swiftlint -- --fix --format",
+    "eslint": "eslint . --ext ts",
+    "prettier": "prettier \"**/*.{css,html,ts,js,java}\"",
+    "swiftlint": "node-swiftlint",
+    "docgen": "docgen --api ExifPlugin --output-readme README.md --output-json dist/docs.json",
+    "build": "npm run clean && npm run docgen && tsc && rollup -c rollup.config.mjs",
+    "clean": "rimraf ./dist",
+    "watch": "tsc --watch",
+    "ios:pod:install": "cd ios && pod install --repo-update && cd ..",
+    "ios:spm:install": "cd ios && swift package resolve && cd ..",
+    "prepublishOnly": "npm run build"
+  },
+  "devDependencies": {
+    "@capacitor/android": "8.0.0",
+    "@capacitor/cli": "8.0.0",
+    "@capacitor/core": "8.0.0",
+    "@capacitor/docgen": "0.3.1",
+    "@capacitor/ios": "8.0.0",
+    "@ionic/eslint-config": "0.4.0",
+    "eslint": "8.57.0",
+    "prettier-plugin-java": "2.6.7",
+    "rimraf": "6.1.2",
+    "rollup": "4.53.3",
+    "swiftlint": "2.0.0",
+    "typescript": "5.9.3"
+  },
+  "peerDependencies": {
+    "@capacitor/core": ">=8.0.0"
+  },
+  "eslintConfig": {
+    "extends": "@ionic/eslint-config/recommended"
+  },
+  "capacitor": {
+    "ios": {
+      "src": "ios"
+    },
+    "android": {
+      "src": "android"
+    }
+  },
+  "publishConfig": {
+    "access": "public"
+  }
+}