diff --git a/build.gradle.kts b/build.gradle.kts index 270fadcf..c9686429 100644 --- a/build.gradle.kts +++ b/build.gradle.kts @@ -1,7 +1,6 @@ // Top-level build file where you can add configuration options common to all sub-projects/modules. @Suppress("DSL_SCOPE_VIOLATION") // TODO: Remove once KTIJ-19369 is fixed plugins { - id("dev.testify") version "3.0.0" apply false alias(libs.plugins.androidApplication) apply false alias(libs.plugins.kotlinAndroid) apply false alias(libs.plugins.serialization) apply false diff --git a/gradle/libs.versions.toml b/gradle/libs.versions.toml index f642979f..bd96736a 100644 --- a/gradle/libs.versions.toml +++ b/gradle/libs.versions.toml @@ -35,6 +35,7 @@ serialization_version = "1.6.0" dropshot_version = "0.5.0" ksp = "2.0.21-1.0.27" install_referrer = "2.2" +webkit = "1.14.0" [libraries] # SQL @@ -53,7 +54,7 @@ revenue_cat = { module = "com.revenuecat.purchases:purchases", version.ref = "re # Browser browser = { module = "androidx.browser:browser", version.ref = "browser_version" } - +webkit = { module = "androidx.webkit:webkit", version.ref = "webkit" } # Compose compose_bom = { module = "androidx.compose:compose-bom", version.ref = "compose_version" } activity_compose = { module = "androidx.activity:activity-compose", version.ref = "activity_compose_version" } diff --git a/superwall/build.gradle.kts b/superwall/build.gradle.kts index 69214676..ed422f29 100644 --- a/superwall/build.gradle.kts +++ b/superwall/build.gradle.kts @@ -198,6 +198,7 @@ dependencies { // Browser implementation(libs.browser) + implementation(libs.webkit) // Core implementation(libs.core) diff --git a/superwall/src/main/java/com/superwall/sdk/config/ConfigManager.kt b/superwall/src/main/java/com/superwall/sdk/config/ConfigManager.kt index 690dd983..a3c143c1 100644 --- a/superwall/src/main/java/com/superwall/sdk/config/ConfigManager.kt +++ b/superwall/src/main/java/com/superwall/sdk/config/ConfigManager.kt @@ -28,6 +28,7 @@ import com.superwall.sdk.models.triggers.Trigger import com.superwall.sdk.network.SuperwallAPI import com.superwall.sdk.network.awaitUntilNetworkExists import com.superwall.sdk.network.device.DeviceHelper +import com.superwall.sdk.paywall.archive.WebArchiveLibrary import com.superwall.sdk.paywall.manager.PaywallManager import com.superwall.sdk.storage.DisableVerboseEvents import com.superwall.sdk.storage.LatestConfig @@ -67,6 +68,7 @@ open class ConfigManager( private val awaitUtilNetwork: suspend () -> Unit = { context.awaitUntilNetworkExists() }, + private val webArchiveLibrary: WebArchiveLibrary, ) { private val CACHE_LIMIT = 1.seconds @@ -151,6 +153,7 @@ open class ConfigManager( } } } catch (e: Throwable) { + e.printStackTrace() // If fetching config fails, default to the cached version // Note: Only a timeout exception is possible here oldConfig?.let { @@ -198,11 +201,20 @@ open class ConfigManager( } else { // If there's no cached enrichment and config refresh is disabled, // try to fetch with 1 sec timeout or fail. - deviceHelper.getEnrichment(0, 1.seconds) + try { + withTimeout(1.seconds) { + return@withTimeout deviceHelper.getEnrichment(0, 1.seconds) + } + } catch (e: Throwable) { + return@async Either.Failure(e) + } } } - val attributesDeferred = ioScope.async { factory.makeSessionDeviceAttributes() } + val attributesDeferred = + ioScope.async { + factory.makeSessionDeviceAttributes() + } // Await results from both operations val (result, enriched, attributes) = @@ -215,6 +227,7 @@ open class ConfigManager( @Suppress("UNCHECKED_CAST") track(InternalSuperwallEvent.DeviceAttributes(attributes as HashMap)) } + val configResult = result as Either val enrichmentResult = enriched as Either configResult @@ -256,7 +269,9 @@ open class ConfigManager( }.fold( onSuccess = { - ioScope.launch { preloadPaywalls() } + ioScope.launch { + preloadPaywalls() + } }, onFailure = { e -> @@ -333,7 +348,7 @@ open class ConfigManager( // Preloads paywalls. private suspend fun preloadPaywalls() { - if (!options.paywalls.shouldPreload) return + if (!options.paywalls.shouldPreload || !options.paywalls.shouldArchive) return preloadAllPaywalls() } diff --git a/superwall/src/main/java/com/superwall/sdk/config/PaywallPreload.kt b/superwall/src/main/java/com/superwall/sdk/config/PaywallPreload.kt index 49b6cde2..47d943b6 100644 --- a/superwall/src/main/java/com/superwall/sdk/config/PaywallPreload.kt +++ b/superwall/src/main/java/com/superwall/sdk/config/PaywallPreload.kt @@ -1,14 +1,17 @@ package com.superwall.sdk.config import android.content.Context +import com.superwall.sdk.dependencies.OptionsFactory import com.superwall.sdk.dependencies.RequestFactory import com.superwall.sdk.dependencies.RuleAttributesFactory import com.superwall.sdk.misc.IOScope import com.superwall.sdk.misc.launchWithTracking import com.superwall.sdk.models.config.Config import com.superwall.sdk.models.paywall.CacheKey +import com.superwall.sdk.models.paywall.Paywall import com.superwall.sdk.models.paywall.PaywallIdentifier import com.superwall.sdk.models.triggers.Trigger +import com.superwall.sdk.paywall.archive.WebArchiveLibrary import com.superwall.sdk.paywall.manager.PaywallManager import com.superwall.sdk.paywall.presentation.rule_logic.javascript.RuleEvaluator import com.superwall.sdk.paywall.request.ResponseIdentifiers @@ -25,8 +28,20 @@ class PaywallPreload( val storage: LocalStorage, val assignments: Assignments, val paywallManager: PaywallManager, + val webArchiveLibrary: WebArchiveLibrary, ) { + val ignoredArchiveUrls = + listOf( + "webflow.com", + "webflow.io", + "builder-templates", + "apple.com", + "templates.superwall.com", + "interceptor.superwallapp.com", + ) + interface Factory : + OptionsFactory, RequestFactory, RuleAttributesFactory, RuleEvaluator.Factory @@ -57,7 +72,10 @@ class PaywallPreload( unconfirmedAssignments = assignments.unconfirmedAssignments, expressionEvaluator = expressionEvaluator, ) - preloadPaywalls(paywallIdentifiers = paywallIds) + preloadPaywalls( + paywallIdentifiers = paywallIds, + paywalls = config.paywalls.filter { it.identifier in paywallIds }, + ) currentPreloadingTask = null } @@ -74,49 +92,77 @@ class PaywallPreload( config, triggersToPreload.toSet(), ) - preloadPaywalls(triggerPaywallIdentifiers) + preloadPaywalls( + triggerPaywallIdentifiers, + config.paywalls.filter { it.identifier in triggerPaywallIdentifiers }, + ) } // Preloads paywalls referenced by triggers. - private suspend fun preloadPaywalls(paywallIdentifiers: Set) { + private suspend fun preloadPaywalls( + paywallIdentifiers: Set, + paywalls: List, + ) { val webviewExists = webViewExists() + val paywalls = + paywalls + .filter { it.identifier in paywallIdentifiers } + .distinctBy { it.identifier } + .filter { + !ignoredArchiveUrls.any { url -> it.url.value.contains(url) } + } + + val shouldArchive = factory.makeSuperwallOptions().paywalls.shouldArchive + val shouldPreload = factory.makeSuperwallOptions().paywalls.shouldPreload + + val identifiersToDownload = + if (shouldArchive) paywalls.map { it.identifier } else emptyList() + if (webviewExists) { scope.launchWithTracking { - // List to hold all the Deferred objects - val tasks = mutableListOf>() - - for (identifier in paywallIdentifiers) { - val task = - async { - // Your asynchronous operation - val request = - factory.makePaywallRequest( - eventData = null, - responseIdentifiers = - ResponseIdentifiers( - paywallId = identifier, - experiment = null, - ), - overrides = null, - isDebuggerLaunched = false, - presentationSourceType = null, - ) - try { - paywallManager.getPaywallView( - request = request, - isForPresentation = true, - isPreloading = true, - delegate = null, - ) - } catch (e: Exception) { - // Handle exception + // If archiving is enable, cache the available paywalls first + if (shouldArchive) { + async { + cachePaywallsFromManifest(paywalls.toSet()) + }.await() + } + // If preloading is enabled, preload the paywalls after archiving them + if (shouldPreload) { + val tasks = mutableListOf>() + for (identifier in paywallIdentifiers.filter { it !in identifiersToDownload }) { + val task = + async { + // Your asynchronous operation + val request = + factory.makePaywallRequest( + eventData = null, + responseIdentifiers = + ResponseIdentifiers( + paywallId = identifier, + experiment = null, + ), + overrides = null, + isDebuggerLaunched = false, + presentationSourceType = null, + ) + + try { + paywallManager.getPaywallView( + request = request, + isForPresentation = true, + isPreloading = true, + delegate = null, + ) + } catch (e: Exception) { + // Handle exception + } } - } - tasks.add(task) + tasks.add(task) + } + // Await all tasks + tasks.awaitAll() } - // Await all tasks - tasks.awaitAll() } } } @@ -166,4 +212,16 @@ class PaywallPreload( paywallManager.removePaywallView(it) } } + + private suspend fun cachePaywallsFromManifest(paywalls: Set) { + paywalls + .distinctBy { it.identifier } + .filter { + !ignoredArchiveUrls.any { url -> it.url.value.contains(url) } + }.map { + scope.async { + webArchiveLibrary.downloadManifest(it.identifier, it.url.value, it.manifest) + } + }.awaitAll() + } } diff --git a/superwall/src/main/java/com/superwall/sdk/config/options/PaywallOptions.kt b/superwall/src/main/java/com/superwall/sdk/config/options/PaywallOptions.kt index 37e9f6fc..77654da4 100644 --- a/superwall/src/main/java/com/superwall/sdk/config/options/PaywallOptions.kt +++ b/superwall/src/main/java/com/superwall/sdk/config/options/PaywallOptions.kt @@ -40,6 +40,8 @@ class PaywallOptions { // or ``Superwall/preloadPaywalls(forEvents:)`` var shouldPreload: Boolean = true + var shouldArchive: Boolean = false + // Loads paywall template websites from disk, if available. Defaults to `true`. // // When you save a change to your paywall in the Superwall dashboard, a key is diff --git a/superwall/src/main/java/com/superwall/sdk/dependencies/DependencyContainer.kt b/superwall/src/main/java/com/superwall/sdk/dependencies/DependencyContainer.kt index b92a73e8..cd4d2887 100644 --- a/superwall/src/main/java/com/superwall/sdk/dependencies/DependencyContainer.kt +++ b/superwall/src/main/java/com/superwall/sdk/dependencies/DependencyContainer.kt @@ -42,6 +42,7 @@ import com.superwall.sdk.models.events.EventData import com.superwall.sdk.models.paywall.Paywall import com.superwall.sdk.models.product.ProductVariable import com.superwall.sdk.network.Api +import com.superwall.sdk.network.ArchiveService import com.superwall.sdk.network.BaseHostService import com.superwall.sdk.network.CollectorService import com.superwall.sdk.network.EnrichmentService @@ -52,6 +53,11 @@ import com.superwall.sdk.network.SubscriptionService import com.superwall.sdk.network.device.DeviceHelper import com.superwall.sdk.network.device.DeviceInfo import com.superwall.sdk.network.session.CustomHttpUrlConnection +import com.superwall.sdk.paywall.archive.Base64ArchiveEncoder +import com.superwall.sdk.paywall.archive.CachedArchiveLibrary +import com.superwall.sdk.paywall.archive.ManifestDownloader +import com.superwall.sdk.paywall.archive.StreamArchiveCompressor +import com.superwall.sdk.paywall.archive.WebArchiveLibrary import com.superwall.sdk.paywall.manager.PaywallManager import com.superwall.sdk.paywall.manager.PaywallViewCache import com.superwall.sdk.paywall.presentation.PaywallInfo @@ -154,7 +160,7 @@ class DependencyContainer( var storeManager: StoreManager val transactionManager: TransactionManager val googleBillingWrapper: GoogleBillingWrapper - + var archive: WebArchiveLibrary var entitlements: Entitlements lateinit var reedemer: WebPaywallRedeemer private val uiScope @@ -274,6 +280,7 @@ class DependencyContainer( factory = this, customHttpUrlConnection = httpConnection, ), + archiveService = ArchiveService(httpConnection), factory = this, ) errorTracker = ErrorTracker(scope = ioScope, cache = storage) @@ -306,6 +313,13 @@ class DependencyContainer( ioScope, ) + archive = + CachedArchiveLibrary( + storage, + ManifestDownloader(IOScope(), network), + StreamArchiveCompressor(encoder = Base64ArchiveEncoder()), + ) + paywallPreload = PaywallPreload( factory = this, @@ -313,6 +327,7 @@ class DependencyContainer( assignments = assignments, paywallManager = paywallManager, scope = ioScope, + webArchiveLibrary = archive, ) configManager = @@ -333,6 +348,7 @@ class DependencyContainer( }, entitlements = entitlements, webPaywallRedeemer = { reedemer }, + webArchiveLibrary = archive, ) reedemer = @@ -753,6 +769,8 @@ class DependencyContainer( override fun makeSuperwallOptions(): SuperwallOptions = configManager.options + override fun webArchive(): WebArchiveLibrary = archive + override suspend fun makeTriggers(): Set = configManager.triggersByEventName.keys override suspend fun provideRuleEvaluator(context: Context): ExpressionEvaluating = evaluator diff --git a/superwall/src/main/java/com/superwall/sdk/dependencies/FactoryProtocols.kt b/superwall/src/main/java/com/superwall/sdk/dependencies/FactoryProtocols.kt index 7f940663..a18e98d2 100644 --- a/superwall/src/main/java/com/superwall/sdk/dependencies/FactoryProtocols.kt +++ b/superwall/src/main/java/com/superwall/sdk/dependencies/FactoryProtocols.kt @@ -25,6 +25,7 @@ import com.superwall.sdk.network.Api import com.superwall.sdk.network.JsonFactory import com.superwall.sdk.network.device.DeviceHelper import com.superwall.sdk.network.device.DeviceInfo +import com.superwall.sdk.paywall.archive.WebArchiveLibrary import com.superwall.sdk.paywall.manager.PaywallViewCache import com.superwall.sdk.paywall.presentation.internal.PresentationRequest import com.superwall.sdk.paywall.presentation.internal.PresentationRequestType @@ -189,6 +190,8 @@ interface StoreTransactionFactory { interface OptionsFactory { fun makeSuperwallOptions(): SuperwallOptions + + fun webArchive(): WebArchiveLibrary } interface TriggerFactory { diff --git a/superwall/src/main/java/com/superwall/sdk/logger/LogScope.kt b/superwall/src/main/java/com/superwall/sdk/logger/LogScope.kt index 129d03e2..1a39fa3b 100644 --- a/superwall/src/main/java/com/superwall/sdk/logger/LogScope.kt +++ b/superwall/src/main/java/com/superwall/sdk/logger/LogScope.kt @@ -26,6 +26,7 @@ enum class LogScope { paywallView, nativePurchaseController, cache, + webarchive, all, ; diff --git a/superwall/src/main/java/com/superwall/sdk/misc/Either.kt b/superwall/src/main/java/com/superwall/sdk/misc/Either.kt index 28e327b4..4de93345 100644 --- a/superwall/src/main/java/com/superwall/sdk/misc/Either.kt +++ b/superwall/src/main/java/com/superwall/sdk/misc/Either.kt @@ -77,7 +77,7 @@ suspend fun Either.onErrorAsync(onError: suspend (E) -> suspend fun eitherWithTimeout( duration: Duration, - error: () -> E, + error: (Throwable) -> E, run: suspend () -> Either, ): Either { return try { @@ -85,7 +85,8 @@ suspend fun eitherWithTimeout( return@withTimeout run() } } catch (e: Throwable) { - Either.Failure(error()) + e.printStackTrace() + Either.Failure(error(e)) } } diff --git a/superwall/src/main/java/com/superwall/sdk/models/paywall/Paywall.kt b/superwall/src/main/java/com/superwall/sdk/models/paywall/Paywall.kt index 06efac26..527a2f74 100644 --- a/superwall/src/main/java/com/superwall/sdk/models/paywall/Paywall.kt +++ b/superwall/src/main/java/com/superwall/sdk/models/paywall/Paywall.kt @@ -64,7 +64,7 @@ data class Paywall( "Unknown or unsupported presentation style: $presentationStyle", ) }, - delay = presentationDelay, + delay = 0, ), @SerialName("background_color_hex") val backgroundColorHex: String, @@ -122,6 +122,8 @@ data class Paywall( var surveys: List = emptyList(), @SerialName("is_scroll_enabled") val isScrollEnabled: Boolean? = true, + @SerialName("manifest") + val manifest: WebArchiveManifest? = null, ) : SerializableEntity { // Public getter for productItems var productItems: List @@ -266,6 +268,12 @@ data class Paywall( cacheKey = "123", buildId = "test", isScrollEnabled = true, + manifest = + WebArchiveManifest( + WebArchiveManifest.Usage.NEVER, + WebArchiveManifest.Document("", ""), + emptyList(), + ), ) } } diff --git a/superwall/src/main/java/com/superwall/sdk/models/paywall/WebArchiveManifest.kt b/superwall/src/main/java/com/superwall/sdk/models/paywall/WebArchiveManifest.kt new file mode 100644 index 00000000..ea0b6272 --- /dev/null +++ b/superwall/src/main/java/com/superwall/sdk/models/paywall/WebArchiveManifest.kt @@ -0,0 +1,44 @@ +package com.superwall.sdk.models.paywall + +import kotlinx.serialization.SerialName +import kotlinx.serialization.Serializable + +@Serializable +data class WebArchiveManifest( + @SerialName("use") val use: Usage, + @SerialName("document") val document: Document, + @SerialName("resources") val resources: List, +) { + sealed interface ManifestPart { + val url: String + val mimeType: String + } + + @Serializable + enum class Usage { + @SerialName("IF_AVAILABLE_ON_PAYWALL_OPEN") + IF_AVAILABLE_ON_PAYWALL_OPEN, + + @SerialName("NEVER") + NEVER, + + @SerialName("ALWAYS") + ALWAYS, + } + + @Serializable + data class Document( + @SerialName("url") + override val url: String, + @SerialName("mime_type") + override val mimeType: String, + ) : ManifestPart + + @Serializable + data class Resource( + @SerialName("url") + override val url: String, + @SerialName("mime_type") + override val mimeType: String, + ) : ManifestPart +} diff --git a/superwall/src/main/java/com/superwall/sdk/network/ArchiveService.kt b/superwall/src/main/java/com/superwall/sdk/network/ArchiveService.kt new file mode 100644 index 00000000..68c0cf7a --- /dev/null +++ b/superwall/src/main/java/com/superwall/sdk/network/ArchiveService.kt @@ -0,0 +1,33 @@ +package com.superwall.sdk.network + +import android.net.Uri +import com.superwall.sdk.logger.LogLevel +import com.superwall.sdk.logger.LogScope +import com.superwall.sdk.logger.Logger +import com.superwall.sdk.misc.Either +import com.superwall.sdk.misc.onError +import com.superwall.sdk.network.session.CustomHttpUrlConnection +import java.net.URL + +class ArchiveService( + private val customHttpUrlConnection: CustomHttpUrlConnection, +) { + init { + System.setProperty("http.maxConnections", "256") + } + + suspend fun fetchRemoteFile(url: Uri): Either = + customHttpUrlConnection + .downloadFileAt( + url.toString().let { + URL(it) + }, + ).onError { + Logger.debug( + logLevel = LogLevel.error, + scope = LogScope.network, + message = "Request Failed while fetching file at: $url", + error = it, + ) + } +} diff --git a/superwall/src/main/java/com/superwall/sdk/network/FileResponse.kt b/superwall/src/main/java/com/superwall/sdk/network/FileResponse.kt new file mode 100644 index 00000000..4f6494b2 --- /dev/null +++ b/superwall/src/main/java/com/superwall/sdk/network/FileResponse.kt @@ -0,0 +1,27 @@ +package com.superwall.sdk.network + +data class FileResponse( + val content: ByteArray, + val type: String?, + val extras: Map, +) { + override fun equals(other: Any?): Boolean { + if (this === other) return true + if (javaClass != other?.javaClass) return false + + other as FileResponse + + if (!content.contentEquals(other.content)) return false + if (type != other.type) return false + if (extras != other.extras) return false + + return true + } + + override fun hashCode(): Int { + var result = content.contentHashCode() + result = 31 * result + type.hashCode() + result = 31 * result + extras.hashCode() + return result + } +} diff --git a/superwall/src/main/java/com/superwall/sdk/network/Network.kt b/superwall/src/main/java/com/superwall/sdk/network/Network.kt index e73cb0ae..53333faf 100644 --- a/superwall/src/main/java/com/superwall/sdk/network/Network.kt +++ b/superwall/src/main/java/com/superwall/sdk/network/Network.kt @@ -1,5 +1,6 @@ package com.superwall.sdk.network +import android.net.Uri import com.superwall.sdk.analytics.internal.trackable.InternalSuperwallEvent import com.superwall.sdk.dependencies.ApiFactory import com.superwall.sdk.logger.LogLevel @@ -35,6 +36,7 @@ open class Network( private val enrichmentService: EnrichmentService, private val factory: ApiFactory, private val subscriptionService: SubscriptionService, + private val archiveService: ArchiveService, ) : SuperwallAPI { override suspend fun sendEvents(events: EventsRequest): Either = collectorService @@ -136,6 +138,14 @@ open class Network( .redeemToken(codes, userId, aliasId, vendorId, receipts) .logError("/redeem") + override suspend fun fetchRemoteFile( + url: Uri, + id: String, + ): Either = + archiveService + .fetchRemoteFile(url) + .logError("$url") + override suspend fun webEntitlementsByUserId( userId: UserId, deviceId: DeviceVendorId, diff --git a/superwall/src/main/java/com/superwall/sdk/network/RequestExecutor.kt b/superwall/src/main/java/com/superwall/sdk/network/RequestExecutor.kt index 93e69b3a..c52d4a6f 100644 --- a/superwall/src/main/java/com/superwall/sdk/network/RequestExecutor.kt +++ b/superwall/src/main/java/com/superwall/sdk/network/RequestExecutor.kt @@ -25,7 +25,6 @@ class RequestExecutor( val auth = request?.getRequestProperty("Authorization") ?: return Either.Failure(NetworkError.NotAuthenticated()) - Logger.debug( LogLevel.debug, LogScope.network, @@ -45,10 +44,11 @@ class RequestExecutor( } var responseMessage: String? = null - + var bytes: ByteArray? = null when (responseCode) { in 200..299 -> { - responseMessage = request.inputStream.bufferedReader().use { it.readText() } + bytes = request.inputStream.use { it.readBytes() } + responseMessage = bytes.toString(Charsets.UTF_8) request.disconnect() } HttpURLConnection.HTTP_MOVED_PERM, HttpURLConnection.HTTP_MOVED_TEMP, HttpURLConnection.HTTP_SEE_OTHER -> { @@ -107,6 +107,7 @@ class RequestExecutor( responseMessage, requestDuration, headers, + bytes, ), ) } catch (e: Throwable) { diff --git a/superwall/src/main/java/com/superwall/sdk/network/RequestResult.kt b/superwall/src/main/java/com/superwall/sdk/network/RequestResult.kt index 1c922068..592e8220 100644 --- a/superwall/src/main/java/com/superwall/sdk/network/RequestResult.kt +++ b/superwall/src/main/java/com/superwall/sdk/network/RequestResult.kt @@ -6,6 +6,7 @@ class RequestResult( val responseMessage: String, val duration: Double, val headers: Map, + val buffer: ByteArray?, ) fun RequestResult.authHeader(): String = headers["Authorization"] ?: "" diff --git a/superwall/src/main/java/com/superwall/sdk/network/ResponseType.kt b/superwall/src/main/java/com/superwall/sdk/network/ResponseType.kt new file mode 100644 index 00000000..8daeb8f0 --- /dev/null +++ b/superwall/src/main/java/com/superwall/sdk/network/ResponseType.kt @@ -0,0 +1,11 @@ +package com.superwall.sdk.network + +sealed class ResponseType { + data class Text( + val string: ByteArray, + ) : ResponseType() + + data class Binary( + val bytes: ByteArray, + ) : ResponseType() +} diff --git a/superwall/src/main/java/com/superwall/sdk/network/SuperwallAPI.kt b/superwall/src/main/java/com/superwall/sdk/network/SuperwallAPI.kt index eed697c6..1bb520ca 100644 --- a/superwall/src/main/java/com/superwall/sdk/network/SuperwallAPI.kt +++ b/superwall/src/main/java/com/superwall/sdk/network/SuperwallAPI.kt @@ -1,5 +1,6 @@ package com.superwall.sdk.network +import android.net.Uri import com.superwall.sdk.misc.Either import com.superwall.sdk.models.assignment.Assignment import com.superwall.sdk.models.assignment.AssignmentPostback @@ -53,4 +54,9 @@ interface SuperwallAPI { vendorId: DeviceVendorId, receipts: List, ): Either + + suspend fun fetchRemoteFile( + url: Uri, + id: String, + ): Either } diff --git a/superwall/src/main/java/com/superwall/sdk/network/device/DeviceHelper.kt b/superwall/src/main/java/com/superwall/sdk/network/device/DeviceHelper.kt index 723b0f05..8ff6db42 100644 --- a/superwall/src/main/java/com/superwall/sdk/network/device/DeviceHelper.kt +++ b/superwall/src/main/java/com/superwall/sdk/network/device/DeviceHelper.kt @@ -46,8 +46,6 @@ import com.superwall.sdk.utilities.DateUtils import com.superwall.sdk.utilities.dateFormat import com.superwall.sdk.utilities.withErrorTracking import kotlinx.coroutines.flow.MutableStateFlow -import kotlinx.coroutines.flow.first -import kotlinx.coroutines.withTimeout import kotlinx.serialization.json.Json import org.threeten.bp.Instant import java.text.SimpleDateFormat @@ -56,7 +54,6 @@ import java.util.Date import java.util.Locale import java.util.TimeZone import kotlin.time.Duration -import kotlin.time.Duration.Companion.minutes enum class InterfaceStyle( val rawValue: String, @@ -452,21 +449,7 @@ class DeviceHelper( return withErrorTracking { val identityInfo = factory.makeIdentityInfo() val aliases = listOf(identityInfo.aliasId) - val geo = - try { - withTimeout(1.minutes) { - lastEnrichment.first { it != null } - } - } catch (e: Throwable) { - Logger.debug( - logLevel = LogLevel.error, - scope = LogScope.device, - message = "Failed to get geo info - timeout", - info = emptyMap(), - error = e, - ) - null - } + val enriched = lastEnrichment.value val capabilities: List = listOf( Capability.PaywallEventReceiver(), diff --git a/superwall/src/main/java/com/superwall/sdk/network/session/CustomURLSession.kt b/superwall/src/main/java/com/superwall/sdk/network/session/CustomURLSession.kt index 775b82c8..1ca19fc1 100644 --- a/superwall/src/main/java/com/superwall/sdk/network/session/CustomURLSession.kt +++ b/superwall/src/main/java/com/superwall/sdk/network/session/CustomURLSession.kt @@ -7,6 +7,7 @@ import com.superwall.sdk.misc.Either import com.superwall.sdk.misc.flatMap import com.superwall.sdk.misc.map import com.superwall.sdk.misc.retrying +import com.superwall.sdk.network.FileResponse import com.superwall.sdk.network.NetworkError import com.superwall.sdk.network.NetworkRequestData import com.superwall.sdk.network.RequestExecutor @@ -14,6 +15,7 @@ import com.superwall.sdk.network.RequestResult import com.superwall.sdk.network.authHeader import kotlinx.serialization.Serializable import kotlinx.serialization.json.Json +import java.net.URL class CustomHttpUrlConnection( val json: Json, @@ -64,4 +66,19 @@ class CustomHttpUrlConnection( } } } + + suspend fun downloadFileAt(url: URL): Either { + val result = + requestExecutor.execute( + NetworkRequestData( + url = url.toURI(), + factory = { _, it -> emptyMap() }, + ), + ) + + return result.map { + val contentType = it.headers.get("Content-Type") + FileResponse(it.buffer!!, contentType, it.headers) + } + } } diff --git a/superwall/src/main/java/com/superwall/sdk/paywall/archive/ArchiveEncoder.kt b/superwall/src/main/java/com/superwall/sdk/paywall/archive/ArchiveEncoder.kt new file mode 100644 index 00000000..711d3640 --- /dev/null +++ b/superwall/src/main/java/com/superwall/sdk/paywall/archive/ArchiveEncoder.kt @@ -0,0 +1,9 @@ +package com.superwall.sdk.paywall.archive + +interface ArchiveEncoder { + fun encode(content: ByteArray): String + + fun decode(content: ByteArray): ByteArray + + fun decodeDefault(string: String): ByteArray +} diff --git a/superwall/src/main/java/com/superwall/sdk/paywall/archive/ArchiveWebClient.kt b/superwall/src/main/java/com/superwall/sdk/paywall/archive/ArchiveWebClient.kt new file mode 100644 index 00000000..e7cd2986 --- /dev/null +++ b/superwall/src/main/java/com/superwall/sdk/paywall/archive/ArchiveWebClient.kt @@ -0,0 +1,124 @@ +package com.superwall.sdk.paywall.archive + +import android.webkit.WebResourceRequest +import android.webkit.WebResourceResponse +import android.webkit.WebView +import androidx.core.net.toUri +import androidx.webkit.WebResourceErrorCompat +import androidx.webkit.WebViewAssetLoader +import com.superwall.sdk.logger.LogLevel +import com.superwall.sdk.logger.LogScope +import com.superwall.sdk.logger.Logger +import com.superwall.sdk.misc.IOScope +import com.superwall.sdk.paywall.archive.models.ArchivePart +import com.superwall.sdk.paywall.archive.models.DecompressedWebArchive +import com.superwall.sdk.paywall.archive.models.MimeType +import com.superwall.sdk.paywall.view.webview.DefaultWebviewClient + +/* +* Routes requests coming to specific URLs to WebArchive files. +* */ +internal class ArchiveWebClient( + private val archive: DecompressedWebArchive, + private val encoder: ArchiveEncoder = Base64ArchiveEncoder(), + onError: (WebResourceErrorCompat) -> Unit, +) : DefaultWebviewClient(ioScope = IOScope()) { + companion object { + const val OVERRIDE_PATH = "https://appassets.androidplatform.net/assets/index.html" + } + + val assetLoader = + WebViewAssetLoader + .Builder() + // Requests coming towards these paths will be intercepted + .addPathHandler("/assets/") { uri -> + val url = resolveUrlFromArchive(archive, uri) + url + }.addPathHandler("/runtime/") { uri -> + val url = resolveUrlFromArchive(archive, uri) + url + }.addPathHandler("/") { uri -> + val url = resolveUrlFromArchive(archive, uri) + url + }.build() + + override fun shouldInterceptRequest( + view: WebView, + request: WebResourceRequest, + ): WebResourceResponse? { + val res = assetLoader.shouldInterceptRequest(request.url.toString().toUri()) + return res + } + + override fun shouldInterceptRequest( + view: WebView?, + url: String, + ): WebResourceResponse? { + val res = assetLoader.shouldInterceptRequest(url.toUri()) + return res + } + + /* + Given an URL and an archive, resolves the URL by looking it up in the archive. + A special case is when the URL is the index.html, in which case we look for the + content type text/html and contentId=index. + * */ + private fun resolveUrlFromArchive( + archiveFile: DecompressedWebArchive, + url: String, + ): WebResourceResponse { + // Find the part that matches the requested url or the main document + // Since they can be relative paths, it checks via .contains + val part = + archiveFile.content.find { part -> + if (url.contains("index.html")) { + part is ArchivePart.Document + } else { + part.url.contains(url) + } + } + if (part == null) { + Logger.debug( + logLevel = LogLevel.debug, + scope = LogScope.webarchive, + message = "No part found for $url", + ) + return WebResourceResponse( + MimeType.HTML.toString(), + "UTF-8", + 404, + "Not found", + mutableMapOf(), + "".toByteArray().inputStream(), + ) + } + val mimeType = part.mimeType + return when (MimeType.fromString(mimeType).type) { + "text" -> { + // Respond with the content as text + val response = + WebResourceResponse( + mimeType.toString(), + "UTF-8", + 200, + "OK", + mutableMapOf(), + part.content.inputStream(), + ) + response + } + + else -> { + // Decode content as base64 + return try { + WebResourceResponse(mimeType.toString(), "UTF-8", encoder.decode(part.content).inputStream()) + } catch ( + e: Throwable, + ) { + e.printStackTrace() + WebResourceResponse(mimeType.toString(), "UTF-8", ByteArray(0).inputStream()) + } + } + } + } +} diff --git a/superwall/src/main/java/com/superwall/sdk/paywall/archive/Base64ArchiveEncoder.kt b/superwall/src/main/java/com/superwall/sdk/paywall/archive/Base64ArchiveEncoder.kt new file mode 100644 index 00000000..70ff2d22 --- /dev/null +++ b/superwall/src/main/java/com/superwall/sdk/paywall/archive/Base64ArchiveEncoder.kt @@ -0,0 +1,57 @@ +package com.superwall.sdk.paywall.archive + +import android.util.Base64 +import android.util.Base64OutputStream +import java.io.OutputStream + +/** + * Base64 implementation of archive encoder + * with specific encoding width for compatibility with + * chrome's export format and email clients + */ + +class StreamingBase64ArchiveEncoder { + fun streamEncode( + input: ByteArray, + out: OutputStream, + ) { + // CRLF line-folds *and* keep underlying stream open + val FLAGS = Base64.CRLF or Base64.NO_CLOSE + + // The flag prevents FileOutputStream from being closed prematurely + Base64OutputStream(out, FLAGS).use { enc -> + enc.write(input) // enc.flush() happens inside use{} automatically + } + } + + fun decodeDefault(encoded: String): ByteArray = + try { + Base64.decode(encoded, Base64.DEFAULT) + } catch (t: Throwable) { + ByteArray(0) + } +} + +class Base64ArchiveEncoder : ArchiveEncoder { + override fun encode(content: ByteArray): String { + return if (content.size > 1) { + return try { + return Base64.encodeToString(content, Base64.CRLF) + } catch (e: Throwable) { + e.printStackTrace() + "ICAgIA==" + } + } else { + "ICAgIA==" + } + } + + // Decodes default B64 + override fun decodeDefault(string: String): ByteArray = Base64.decode(string, Base64.DEFAULT) + + override fun decode(content: ByteArray): ByteArray = + Base64.decode( + content, + Base64.CRLF, + ) +} diff --git a/superwall/src/main/java/com/superwall/sdk/paywall/archive/CachedArchiveLibrary.kt b/superwall/src/main/java/com/superwall/sdk/paywall/archive/CachedArchiveLibrary.kt new file mode 100644 index 00000000..ca6b8f69 --- /dev/null +++ b/superwall/src/main/java/com/superwall/sdk/paywall/archive/CachedArchiveLibrary.kt @@ -0,0 +1,88 @@ +package com.superwall.sdk.paywall.archive + +import com.superwall.sdk.models.paywall.WebArchiveManifest +import com.superwall.sdk.paywall.archive.models.DecompressedWebArchive +import com.superwall.sdk.storage.Storage +import com.superwall.sdk.storage.StoredWebArchive +import kotlinx.coroutines.flow.MutableStateFlow +import kotlinx.coroutines.flow.first +import kotlinx.coroutines.flow.update + +/** + * Manages WebArchives, downloading and saving them to file cache. + */ +class CachedArchiveLibrary( + private val storage: Storage, + private val manifestDownloader: ManifestDownloader, + private val streamArchiveCompressor: StreamArchiveCompressor, +) : WebArchiveLibrary { + // Queue of paywallIds that are currently being downloaded + private val archiveQueue = MutableStateFlow(listOf()) + + override suspend fun downloadManifest( + paywallId: String, + paywallUrl: String, + manifest: WebArchiveManifest?, + ) { + // Return if the paywall is already archived or waiting to be archived + if ( // checkIfArchived(paywallId) || + archiveQueue.value.contains(paywallId) + ) { + return + } + + archiveQueue.update { + it + paywallId + } + + val archive = + manifestDownloader.downloadArchiveForManifest( + paywallId, + manifest ?: WebArchiveManifest( + WebArchiveManifest.Usage.ALWAYS, + WebArchiveManifest.Document(paywallUrl, "text/html"), + emptyList(), + ), + ) + val storable = StoredWebArchive(paywallId) + + storage + .getFileStream( + storable = storable, + ).use { + streamArchiveCompressor.compressToStream(paywallUrl, archive, it) + } + archiveQueue.update { + it.minus(paywallId) + } + } + + // Check if the paywall is archived already + override fun checkIfArchived(paywallId: String): Boolean { + val archive = StoredWebArchive(paywallId) + return storage.readFile(archive) != null + } + + // Load the archive from cache, if it does not exist, throw an exception + override suspend fun loadArchive(paywallId: String): Result { + // If doesn't exist, await until it's downloaded + if (!checkIfArchived(paywallId)) { + awaitUntilQueueResolved(paywallId) + } + val storeable = StoredWebArchive(paywallId) + val fromCache = storage.readFileStream(storeable) + return if (fromCache != null) { + val decompressed = streamArchiveCompressor.decompressArchiveStream(fromCache) + Result.success(decompressed) + } else { + Result.failure(NoSuchElementException("Paywall $paywallId does not exist in cache")) + } + } + + // Checks and awaits if the paywall is in queue, otherwise returns immediately + override suspend fun awaitUntilQueueResolved(paywallId: String) { + archiveQueue.first { + !it.contains(paywallId) + } + } +} diff --git a/superwall/src/main/java/com/superwall/sdk/paywall/archive/ManifestDownloader.kt b/superwall/src/main/java/com/superwall/sdk/paywall/archive/ManifestDownloader.kt new file mode 100644 index 00000000..b2e30eaa --- /dev/null +++ b/superwall/src/main/java/com/superwall/sdk/paywall/archive/ManifestDownloader.kt @@ -0,0 +1,222 @@ +package com.superwall.sdk.paywall.archive + +import androidx.core.net.toUri +import com.superwall.sdk.logger.LogLevel +import com.superwall.sdk.logger.LogScope +import com.superwall.sdk.logger.Logger +import com.superwall.sdk.misc.IOScope +import com.superwall.sdk.misc.map +import com.superwall.sdk.misc.onError +import com.superwall.sdk.models.paywall.WebArchiveManifest +import com.superwall.sdk.network.Network +import com.superwall.sdk.paywall.archive.models.ArchivePart +import com.superwall.sdk.paywall.archive.models.MimeType +import kotlinx.coroutines.CoroutineScope +import kotlinx.coroutines.asCoroutineDispatcher +import kotlinx.coroutines.async +import kotlinx.coroutines.awaitAll +import java.net.URL +import java.util.concurrent.Executors + +/* + Downloads WebArchive parts from a WebArchiveManifest. + Careful, performs a lot of requests in parallel. +*/ +class ManifestDownloader( + private val coroutineScope: CoroutineScope, + private val network: Network, +) { + val dispatcher = + Executors.newFixedThreadPool(64).asCoroutineDispatcher() + + /* + Downloads the archive parts for a given manifest, + starting with the main document, then it's relative dependencies + and all other resources in parallel. + */ + suspend fun downloadArchiveForManifest( + id: String, + manifest: WebArchiveManifest, + ): List { + // Download the main document + val mainDocumentUrl = manifest.document.url + val mainDocument = + network + .fetchRemoteFile(mainDocumentUrl.toUri(), id) + .onError { + Logger.debug( + logLevel = LogLevel.debug, + scope = LogScope.webarchive, + "Failed to download main document: $mainDocumentUrl", + error = it, + info = mapOf("url" to mainDocumentUrl.toString()), + ) + throw it + }.getSuccess()!! + + val mainDocumentString = mainDocument.content.toString(Charsets.UTF_8) + val relativeUrls = discoverRelativeResources(mainDocumentString) + val host = URL(mainDocumentUrl) + val favicoUrl = + WebArchiveManifest.Resource( + "https://${host.host}/favicon.ico", + MimeType.FAVICON.toString(), + ) + val relativeParts = + relativeUrls.map { + WebArchiveManifest.Resource( + url = "https://${host.host}${if (it.key.startsWith("/")) it.key else "/${it.key}"}", + mimeType = it.value, + ) + } + val absoluteParts = + discoverAbsoluteResources(mainDocumentString).map { + WebArchiveManifest.Resource( + it.key, + it.value, + ) + } + + val documentPart = + ArchivePart.Document( + url = mainDocumentUrl.toString(), + content = mainDocument.content, + mimeType = "text/html", + ) + + val foundParts = (absoluteParts + relativeParts + manifest.resources + favicoUrl).toSet() + + val xope = IOScope(dispatcher) + // Combine all resources into a list of deferred jobs + val jobs = + (foundParts).distinctBy { it.url }.map { resource -> + // Creates download tasks + xope.async { + with(resource) { + network + .fetchRemoteFile(resource.url.toUri(), id) + .map { + ArchivePart.Resource( + url = url.toString(), + mimeType = mimeType, + content = it.content, + ) + }.onError { + Logger.debug( + logLevel = LogLevel.debug, + scope = LogScope.webarchive, + "Failed to download resource: $url", + error = it, + info = mapOf("url" to url.toString()), + ) + } + } + } + } + val relativeUrlsOnly = (relativeParts + favicoUrl).map { it.url } + val parts = + jobs + .chunked(16) + .flatMap { it.awaitAll() } + .filter { it.getSuccess() != null } + .map { it.getSuccess()!! } + .map { + if (relativeUrlsOnly.contains(it.url)) { + if (it.url.contains("favicon.ico")) { + "favicon.ico" + } + it.copy(url = it.url.removePrefix("https://${host.host}")) + } else { + it + } + } + + return parts + documentPart + } + + /* + Uses regex to match any absolute resources in the main document that need + to be downloaded for the core runtime. This matches all ="http://" and ="https://" resources + and returns a map of the absolute URL to the mime type judging by the extension + (with a special case for javascript files). + */ + fun discoverAbsoluteResources(mainDocument: String): Map = + Regex("(?:=\"|\":\"|\bsrc\\s*=\\s*\")https?://[^\"]+\"") + .findAll(mainDocument) + .map { + // Extract just the URL part by finding the https:// portion + val match = it.value + val urlStart = + match.indexOf("https://").takeIf { it != -1 } + ?: match.indexOf("http://") + match.substring(urlStart, match.length - 1) // Remove trailing quote + }.filter { + it.removePrefix("https://").contains("/") && !it.contains("w3.org") + }.map { + val type = + when (val extension = it.takeLastWhile { it != '.' }) { + "js" -> "javascript" + else -> extension + } + val mimeType = "text/$type" + it to mimeType + }.toMap() + + /* + Uses regex to match any relative resources in the main document that need + to be downloaded for the core runtime. This matches all ="/runtime/" resources + and returns a map of the relative path to the mime type judging by the extension + (with a special case for javascript files). + */ + fun discoverRelativeResources(mainDocument: String): Map { + val allMatches = mutableListOf() + + // Pattern 1: Attribute assignments with double quotes: attr="/runtime/..." or attr="../..." + val attrDoubleQuotePattern = + Regex("""(?:=|href\s*=\s*)"(/runtime/[^"]+|\.\./[^"]+|build/[^"]+)"""") + allMatches.addAll( + attrDoubleQuotePattern + .findAll(mainDocument) + .map { it.groupValues[1] } + .toList(), + ) + + // Pattern 2: Attribute assignments with single quotes: attr='/runtime/...' or attr='../..' + val attrSingleQuotePattern = + Regex("""(?:=|href\s*=\s*)'(/runtime/[^']+|\.\./[^']+|build/[^']+)'""") + allMatches.addAll( + attrSingleQuotePattern + .findAll(mainDocument) + .map { it.groupValues[1] } + .toList(), + ) + + // Pattern 3: JSON properties with double quotes: "key":"/runtime/..." or "key":"../..." + val jsonPattern = Regex(""""[^"]*":\s*"(/runtime/[^"]+|\.\./[^"]+|build/[^"]+)"""") + allMatches.addAll( + jsonPattern + .findAll(mainDocument) + .map { it.groupValues[1] } + .toList(), + ) + + return allMatches + .map { url -> + val extension = url.substringAfterLast('.', "") + val type = + when (extension) { + "js" -> "javascript" + "" -> "plain" // fallback for URLs without extension + else -> extension + } + val mimeType = "text/$type" + val url = + if (url.startsWith("../")) { + url.drop(3) + } else { + url + } + url to mimeType + }.toMap() + } +} diff --git a/superwall/src/main/java/com/superwall/sdk/paywall/archive/StreamArchiveCompressor.kt b/superwall/src/main/java/com/superwall/sdk/paywall/archive/StreamArchiveCompressor.kt new file mode 100644 index 00000000..998d3249 --- /dev/null +++ b/superwall/src/main/java/com/superwall/sdk/paywall/archive/StreamArchiveCompressor.kt @@ -0,0 +1,370 @@ +package com.superwall.sdk.paywall.archive + +import com.superwall.sdk.paywall.archive.models.ArchiveKeys.CONTENT_ID +import com.superwall.sdk.paywall.archive.models.ArchiveKeys.CONTENT_LOCATION +import com.superwall.sdk.paywall.archive.models.ArchiveKeys.CONTENT_TRANSFER_ENCODING +import com.superwall.sdk.paywall.archive.models.ArchiveKeys.CONTENT_TYPE +import com.superwall.sdk.paywall.archive.models.ArchiveKeys.ContentId +import com.superwall.sdk.paywall.archive.models.ArchiveKeys.TransferEncoding +import com.superwall.sdk.paywall.archive.models.ArchivePart +import com.superwall.sdk.paywall.archive.models.DecompressedWebArchive +import com.superwall.sdk.storage.toMD5 +import java.io.BufferedReader +import java.io.InputStream +import java.io.InputStreamReader +import java.io.OutputStream +import java.nio.charset.StandardCharsets +import java.security.MessageDigest +import kotlin.text.drop +import kotlin.text.trim + +class StreamArchiveCompressor( + val encoder: ArchiveEncoder, +) { + val se = StreamingBase64ArchiveEncoder() + + private val UTF8 = StandardCharsets.UTF_8 + private val CRLF = "\r\n".toByteArray(UTF8) + private val DOUBLE_CRLF = "\r\n\r\n".toByteArray(UTF8) + private val LF = "\n".toByteArray(UTF8) + private val DASH_DASH = "--".toByteArray(UTF8) + private val BOUNDARY_PREFIX = "--" + private val md5 = + MessageDigest + .getInstance("MD5") + + // ---------- helpers ---------- + private fun md5Hex(bytes: ByteArray): String = + md5 + .digest(bytes) + .joinToString("") { "%02x".format(it) } + + /** build a unique multipart boundary from URLs only (no allocations apart from MD5) */ + private fun buildBoundary(parts: List): String { + val md = md5 + parts.forEach { md.update(it.url.toByteArray(UTF8)) } + return md5Hex(md.digest()) + } + + /* ==================================================== + * PUBLIC API + * ==================================================== */ + + /** stream the complete archive to **any** `OutputStream` – no buffering */ + fun compressToStream( + url: String, + parts: List, + out: OutputStream, + ) { + val boundary = buildBoundary(parts) + val boundaryBytes = (BOUNDARY_PREFIX + boundary).toByteArray(UTF8) + + writeHeaders(out, url, boundary) + + // 1️⃣ document (if any) + parts.firstOrNull { it is ArchivePart.Document }?.let { part -> + out.write(CRLF) + out.write(boundaryBytes) + out.write(CRLF) + writeMimeHeaders(out, part) + se.streamEncode(part.content, out) + out.write(CRLF) + } + + // 2️⃣ all remaining resources + for (part in parts) { + if (part !is ArchivePart.Document) { + out.write(CRLF) + out.write(boundaryBytes) + out.write(CRLF) + writeMimeHeaders(out, part) + se.streamEncode(part.content, out) + out.write(CRLF) + } + } + + // closing boundary + out.write(CRLF) + out.write(boundaryBytes) + out.write(DASH_DASH) + out.write(CRLF) + out.flush() + } + + fun decompressArchiveStream(input: InputStream): DecompressedWebArchive { + val reader = BufferedReader(InputStreamReader(input, Charsets.UTF_8)) + val headers = mutableMapOf() + + // --- Read top-level headers --- + while (true) { + val line = reader.readLine() ?: break + if (line.isBlank()) break + val colonIndex = line.indexOf(":") + if (colonIndex > 0) { + val key = line.substring(0, colonIndex).trim() + val value = line.substring(colonIndex + 1).trim().trimEnd(';', ' ') + headers[key] = value + } + } + + val rawBoundary = + headers["Content-Type"] + ?.substringAfter("boundary=\"") + ?.substringBefore("\"") + ?: return DecompressedWebArchive(headers, emptyList()) + val boundaryLine = "--$rawBoundary" + val boundaryEndLine = "--$rawBoundary--" + + val parts = mutableListOf() + var line = reader.readLine() + + while (line != null) { + // Look for next boundary + while (line != null && line != boundaryLine && line != boundaryEndLine) { + line = reader.readLine() + } + if (line == boundaryEndLine || line == null) break + + // --- Parse part headers --- + val partHeaders = mutableMapOf() + while (true) { + line = reader.readLine() ?: break + if (line.isBlank()) break + val colon = line.indexOf(":") + if (colon > 0) { + val key = line.substring(0, colon).trim() + val value = line.substring(colon + 1).trim() + partHeaders[key] = value + } + } + + val url = partHeaders["Content-Location"] ?: continue + val mimeType = partHeaders["Content-Type"] ?: "application/octet-stream" + val cid = partHeaders["Content-Id"] ?: "" + val encoding = partHeaders["Content-Transfer-Encoding"]?.lowercase() ?: "" + + // --- Collect content until next boundary --- + val contentBuffer = StringBuilder() + while (true) { + val nextLine = reader.readLine() ?: break + if (nextLine == boundaryLine || nextLine == boundaryEndLine) { + line = nextLine + break + } + contentBuffer.appendLine(nextLine) + } + + val raw = contentBuffer.toString() + val content: ByteArray = + try { + encoder.decodeDefault(raw.trim()) + } catch (e: Throwable) { + raw.toByteArray(Charsets.UTF_8) // might be binary-ish but works for text/html + } + + val part = + if (cid.contains(ContentId.MAIN_DOCUMENT.key)) { + ArchivePart.Document(url, mimeType, content) + } else { + ArchivePart.Resource(url, mimeType, content) + } + parts.add(part) + } + + return DecompressedWebArchive(headers, parts) + } + + /* ==================================================== + * INTERNAL HELPERS + * ==================================================== */ + + // ---------- write-side helpers ---------- + private fun writeHeaders( + out: OutputStream, + url: String, + boundary: String, + ) { + out.write("From: ".toByteArray(UTF8)) + out.write(CRLF) + out.write("MIME-Version: 1.0".toByteArray(UTF8)) + out.write(CRLF) + out.write("Subject: Superwall Web Archive".toByteArray(UTF8)) + out.write(CRLF) + out.write("Snapshot-Content-Location: ".toByteArray(UTF8)) + out.write(url.toByteArray(UTF8)) + out.write(CRLF) + out.write( + "Content-Type: multipart/related; type=\"text/html\"; boundary=\"".toByteArray( + UTF8, + ), + ) + out.write(boundary.toByteArray(UTF8)) + out.write("\"".toByteArray(UTF8)) + out.write(CRLF) + } + + private fun writeMimeHeaders( + out: OutputStream, + part: ArchivePart, + ) { + out.write("${CONTENT_TYPE.key}: ${part.mimeType}".toByteArray(UTF8)) + out.write(CRLF) + val enc = + if (part.mimeType.contains("text")) { + TransferEncoding.QUOTED_PRINTABLE.key + } else { + TransferEncoding.BASE64.key + } + out.write("${CONTENT_TRANSFER_ENCODING.key}: $enc".toByteArray(UTF8)) + out.write(CRLF) + out.write("${CONTENT_LOCATION.key}: ${part.url}".toByteArray(UTF8)) + out.write(CRLF) + out.write("${CONTENT_ID.key}: ${part.contentId}".toByteArray(UTF8)) + out.write(DOUBLE_CRLF) + } + + // ---------- header parsing ---------- + private fun parseHeaders( + bytes: ByteArray, + from: Int, + to: Int, + ): Map { + val map = mutableMapOf() + val sep = ": ".toByteArray(UTF8) + + var i = from + while (i < to) { + val lineEnd = findSequence(bytes, LF, i).let { if (it < 0 || it > to) to else it } + val slice = bytes.sliceArray(i until lineEnd) + val colon = findSequence(slice, sep, 0) + if (colon >= 0) { + val key = String(slice, 0, colon, UTF8).trimEnd('\r') + val value = + String( + slice, + colon + sep.size, + slice.size - colon - sep.size, + UTF8, + ).trimEnd('\r', ';', ' ') + map[key] = value + } + i = lineEnd + 1 + } + return map + } + + // ---------- part extraction ---------- + private fun findSequence( + hay: ByteArray, + needle: ByteArray, + start: Int, + fail: IntArray = IntArray(0), + ): Int { + if (needle.isEmpty() || start >= hay.size) return -1 + + // simple scan if no failure table + if (fail.isEmpty()) { + outer@ for (i in start..hay.size - needle.size) { + for (j in needle.indices) if (hay[i + j] != needle[j]) continue@outer + return i + } + return -1 + } + + var j = 0 + for (i in start until hay.size) { + while (j > 0 && hay[i] != needle[j]) j = fail[j - 1] + if (hay[i] == needle[j]) j++ + if (j == needle.size) return i - j + 1 + } + return -1 + } + + // Creates multipart from a list of ArchiveParts and a base URL + fun List.createMultipartHTML( + url: String, + encoder: ArchiveEncoder, + ): String { + val archiveHash = joinToString(separator = "") { it.url }.toMD5() + + // Generated boundary - a separator for different parts in a MHTML file + val boundary = "----MultipartBoundary--$archiveHash----" + // Header for the MHTML file, mostly unimportant except + // for the boundary and the content location + val header = + listOf( + "From" to "", + "MIME-Version" to "1.0", + "Subject" to "Superwall Web Archive", + "Snapshot-Content-Location" to url, + "Content-Type" to "multipart/related;type=\"text/html\";boundary=\"$boundary\"", + ).joinToString("\n") { "${it.first}: ${it.second}" } + + // Ensure document is first in the list + val document = find { it is ArchivePart.Document } + val resources = filter { it !is ArchivePart.Document } + // Join document and resources as parts separated by boundary + val combinedParts = + (listOf(document) + resources) + .filterNotNull() + .map { it?.toMimePart(encoder) } + // Return file as a combination of header and parts separated by boundary + val mhtml = + (listOf(header).plus(combinedParts)).joinToString( + "\n\n--$boundary\n", + postfix = "\n--$boundary", + ) + + return mhtml + } + + // Extracts header parts of a mhtml and parses it into a map + fun String.extractHeader(): Pair, String> { + val trimmed = lines().drop(lines().takeWhile { it.isBlank() }.size) + val header = + trimmed + .takeWhile { it.isNotEmpty() } + + val headerParts = + header + .flatMap { + it + .split(": ", ";", "=") + .chunked(2) + .map { it.first().trim() to it.last() } + }.toMap() + + val remaining = trimmed.drop(header.size).joinToString("\n") + return headerParts to remaining + } + + fun ArchivePart.toMimePart(encoder: ArchiveEncoder): String { + val content = + when (this) { + is ArchivePart.Document -> + encoder.encode(content) + + is ArchivePart.Resource -> { + if (mimeType.contains("text")) { + encoder.encode(content) + } else { + encoder.encode(content) + } + } + } + + val header = + listOf( + CONTENT_TYPE to mimeType, + CONTENT_TRANSFER_ENCODING to + if (mimeType.contains("text")) { + TransferEncoding.QUOTED_PRINTABLE.key + } else { + TransferEncoding.BASE64.key + }, + CONTENT_LOCATION to url, + CONTENT_ID to contentId, + ).joinToString("") { "${it.first.key}: ${it.second}\n" } + return "$header\n\n$content" + } +} diff --git a/superwall/src/main/java/com/superwall/sdk/paywall/archive/StringArchiveCompressor.kt b/superwall/src/main/java/com/superwall/sdk/paywall/archive/StringArchiveCompressor.kt new file mode 100644 index 00000000..d63aa02a --- /dev/null +++ b/superwall/src/main/java/com/superwall/sdk/paywall/archive/StringArchiveCompressor.kt @@ -0,0 +1,207 @@ +package com.superwall.sdk.paywall.archive + +import com.superwall.sdk.paywall.archive.models.ArchiveKeys.CONTENT_ID +import com.superwall.sdk.paywall.archive.models.ArchiveKeys.CONTENT_LOCATION +import com.superwall.sdk.paywall.archive.models.ArchiveKeys.CONTENT_TRANSFER_ENCODING +import com.superwall.sdk.paywall.archive.models.ArchiveKeys.CONTENT_TYPE +import com.superwall.sdk.paywall.archive.models.ArchiveKeys.ContentId +import com.superwall.sdk.paywall.archive.models.ArchiveKeys.TransferEncoding +import com.superwall.sdk.paywall.archive.models.ArchivePart +import com.superwall.sdk.paywall.archive.models.DecompressedWebArchive +import com.superwall.sdk.storage.toMD5 +import java.nio.charset.StandardCharsets +import java.security.MessageDigest + +typealias CompressedWebArchive = String + +interface ArchiveCompressor { + fun compressToArchive( + url: String, + parts: List, + ): Output + + fun decompressFromArchive(archiveType: ArchiveType): Output +} + +/* + Creates a multipart HTML file from a list of ArchiveParts and vice-versa +*/ +class StringArchiveCompressor( + val encoder: ArchiveEncoder, +) { + val se = StreamingBase64ArchiveEncoder() + + fun compressToArchive( + url: String, + parts: List, + ): CompressedWebArchive = parts.createMultipartHTML(url, encoder) + + fun decompressArchive(archive: CompressedWebArchive): DecompressedWebArchive { + // Extract the header and the remaining content + val (headerParts, remaining) = archive.extractHeader() + + // Find the boundary delimiter + val boundary = headerParts["boundary"]?.drop(1)?.dropLast(1) + + // Split using the delimiter to get embedded documents + // Note: the first two dashes are used to indicate the start of the boundary + val parts = remaining.split("--$boundary") + + val archiveParts = + parts + // Filter out empty parts + .filter { !it.isBlank() } + .map { + // Extract map of content headers + val (headerParts, remaining) = it.extractHeader() + // Since some content can be text that is b64 encoded but not declared such + // we check if the content is base64 encoded by trying to decode it + val content = + try { + encoder.decodeDefault(remaining.trimEmptyLines().trim()) + } catch (e: Throwable) { + e.printStackTrace() + remaining.trimEmptyLines().toByteArray(Charsets.UTF_8) + } + headerParts to content + }.map { + val headers = it.first + val url = headers[CONTENT_LOCATION.key]?.trim() ?: "" + val mimeType = headers[CONTENT_TYPE.key]?.trim() ?: "" + val contentId = headers[CONTENT_ID.key]?.trim() ?: "" + if (contentId.contains(ContentId.MAIN_DOCUMENT.key)) { + ArchivePart.Document( + url = url, + mimeType = mimeType, + content = it.second, + ) + } else { + ArchivePart.Resource( + url = url, + mimeType = mimeType, + content = it.second, + ) + } + } + return DecompressedWebArchive(headerParts, archiveParts) + } + + private val UTF8 = StandardCharsets.UTF_8 + private val CRLF = "\r\n".toByteArray(UTF8) + private val DOUBLE_CRLF = "\r\n\r\n".toByteArray(UTF8) + private val LF = "\n".toByteArray(UTF8) + private val DASH_DASH = "--".toByteArray(UTF8) + private val BOUNDARY_PREFIX = "--" + + // ---------- helpers ---------- + private fun md5Hex(bytes: ByteArray): String = + MessageDigest + .getInstance("MD5") + .digest(bytes) + .joinToString("") { "%02x".format(it) } + + /** build a unique multipart boundary from URLs only (no allocations apart from MD5) */ + private fun buildBoundary(parts: List): String { + val md = MessageDigest.getInstance("MD5") + parts.forEach { md.update(it.url.toByteArray(UTF8)) } + return md5Hex(md.digest()) + } + + /* ==================================================== + * PUBLIC API + * ==================================================== */ +} + +private fun String.trimEmptyLines() = + lines() + .dropWhile { it.isEmpty() } + .joinToString("\n") + .trim() + +// Creates multipart from a list of ArchiveParts and a base URL +fun List.createMultipartHTML( + url: String, + encoder: ArchiveEncoder, +): String { + val archiveHash = joinToString(separator = "") { it.url }.toMD5() + + // Generated boundary - a separator for different parts in a MHTML file + val boundary = "----MultipartBoundary--$archiveHash----" + // Header for the MHTML file, mostly unimportant except + // for the boundary and the content location + val header = + listOf( + "From" to "", + "MIME-Version" to "1.0", + "Subject" to "Superwall Web Archive", + "Snapshot-Content-Location" to url, + "Content-Type" to "multipart/related;type=\"text/html\";boundary=\"$boundary\"", + ).joinToString("\n") { "${it.first}: ${it.second}" } + + // Ensure document is first in the list + val document = find { it is ArchivePart.Document } + val resources = filter { it !is ArchivePart.Document } + // Join document and resources as parts separated by boundary + val combinedParts = + (listOf(document) + resources) + .filterNotNull() + .map { it?.toMimePart(encoder) } + // Return file as a combination of header and parts separated by boundary + val mhtml = + (listOf(header).plus(combinedParts)).joinToString( + "\n\n--$boundary\n", + postfix = "\n--$boundary", + ) + + return mhtml +} + +// Extracts header parts of a mhtml and parses it into a map +fun String.extractHeader(): Pair, String> { + val trimmed = lines().drop(lines().takeWhile { it.isBlank() }.size) + val header = + trimmed + .takeWhile { it.isNotEmpty() } + + val headerParts = + header + .flatMap { + it + .split(": ", ";", "=") + .chunked(2) + .map { it.first().trim() to it.last() } + }.toMap() + + val remaining = trimmed.drop(header.size).joinToString("\n") + return headerParts to remaining +} + +fun ArchivePart.toMimePart(encoder: ArchiveEncoder): String { + val content = + when (this) { + is ArchivePart.Document -> + encoder.encode(content) + + is ArchivePart.Resource -> { + if (mimeType.contains("text")) { + encoder.encode(content) + } else { + encoder.encode(content) + } + } + } + + val header = + listOf( + CONTENT_TYPE to mimeType, + CONTENT_TRANSFER_ENCODING to + if (mimeType.contains("text")) { + TransferEncoding.QUOTED_PRINTABLE.key + } else { + TransferEncoding.BASE64.key + }, + CONTENT_LOCATION to url, + CONTENT_ID to contentId, + ).joinToString("") { "${it.first.key}: ${it.second}\n" } + return "$header\n\n$content" +} diff --git a/superwall/src/main/java/com/superwall/sdk/paywall/archive/WebArchiveLibrary.kt b/superwall/src/main/java/com/superwall/sdk/paywall/archive/WebArchiveLibrary.kt new file mode 100644 index 00000000..2eef9ea2 --- /dev/null +++ b/superwall/src/main/java/com/superwall/sdk/paywall/archive/WebArchiveLibrary.kt @@ -0,0 +1,18 @@ +package com.superwall.sdk.paywall.archive + +import com.superwall.sdk.models.paywall.WebArchiveManifest +import com.superwall.sdk.paywall.archive.models.DecompressedWebArchive + +interface WebArchiveLibrary { + suspend fun downloadManifest( + paywallId: String, + paywallUrl: String, + manifest: WebArchiveManifest?, + ) + + fun checkIfArchived(paywallId: String): Boolean + + suspend fun loadArchive(paywallId: String): Result + + suspend fun awaitUntilQueueResolved(identifier: String) +} diff --git a/superwall/src/main/java/com/superwall/sdk/paywall/archive/models/ArchiveKeys.kt b/superwall/src/main/java/com/superwall/sdk/paywall/archive/models/ArchiveKeys.kt new file mode 100644 index 00000000..f9dcacf7 --- /dev/null +++ b/superwall/src/main/java/com/superwall/sdk/paywall/archive/models/ArchiveKeys.kt @@ -0,0 +1,32 @@ +package com.superwall.sdk.paywall.archive.models + +enum class ArchiveKeys( + val key: String, +) { + CONTENT_TYPE("Content-Type"), + CONTENT_ID("Content-Id"), + CONTENT_LOCATION("Content-Location"), + CONTENT_TRANSFER_ENCODING("Content-Transfer-Encoding"), + ; + + override fun toString() = key + + enum class TransferEncoding( + val key: String, + ) { + QUOTED_PRINTABLE("quoted-printable"), + BASE64("base64"), + ; + + override fun toString() = key + } + + enum class ContentId( + val key: String, + ) { + MAIN_DOCUMENT(""), + ; + + override fun toString() = key + } +} diff --git a/superwall/src/main/java/com/superwall/sdk/paywall/archive/models/ArchivePart.kt b/superwall/src/main/java/com/superwall/sdk/paywall/archive/models/ArchivePart.kt new file mode 100644 index 00000000..5b4fd7ae --- /dev/null +++ b/superwall/src/main/java/com/superwall/sdk/paywall/archive/models/ArchivePart.kt @@ -0,0 +1,33 @@ +package com.superwall.sdk.paywall.archive.models + +import com.superwall.sdk.storage.toMD5 + +sealed interface ArchivePart { + val url: String + val mimeType: String + val content: ByteArray + val contentId: String + + fun getSizeInMB(): String { + val sizeInMB = content.size.toDouble() / (1024 * 1024) + return String.format("%.2f MB", sizeInMB) + } + + fun getSizeInMbDouble(): Double = content.size.toDouble() / (1024 * 1024) + + data class Resource( + override val url: String, + override val mimeType: String, + override val content: ByteArray, + ) : ArchivePart { + override val contentId: String = "${url.toMD5()}" + } + + data class Document( + override val url: String, + override val mimeType: String, + override val content: ByteArray, + ) : ArchivePart { + override val contentId: String = ArchiveKeys.ContentId.MAIN_DOCUMENT.key + } +} diff --git a/superwall/src/main/java/com/superwall/sdk/paywall/archive/models/DecompressedWebArchive.kt b/superwall/src/main/java/com/superwall/sdk/paywall/archive/models/DecompressedWebArchive.kt new file mode 100644 index 00000000..4a33d15a --- /dev/null +++ b/superwall/src/main/java/com/superwall/sdk/paywall/archive/models/DecompressedWebArchive.kt @@ -0,0 +1,6 @@ +package com.superwall.sdk.paywall.archive.models + +data class DecompressedWebArchive( + val header: Map, + val content: List, +) diff --git a/superwall/src/main/java/com/superwall/sdk/paywall/archive/models/MimeType.kt b/superwall/src/main/java/com/superwall/sdk/paywall/archive/models/MimeType.kt new file mode 100644 index 00000000..3b566687 --- /dev/null +++ b/superwall/src/main/java/com/superwall/sdk/paywall/archive/models/MimeType.kt @@ -0,0 +1,26 @@ +package com.superwall.sdk.paywall.archive.models + +data class MimeType( + val type: String, + val subtype: String, +) { + companion object { + fun fromString(mimeType: String): MimeType { + val parts = mimeType.split("/") + return MimeType(parts[0], parts[1]) + } + + val HTML = MimeType("text", "html") + val FAVICON = MimeType("image", "x-icon") + } + + override fun toString(): String = "$type/$subtype" + + override fun equals(other: Any?): Boolean { + when (other) { + is MimeType -> return type == other.type && subtype == other.subtype + is String -> return toString() == other + else -> return super.equals(other) + } + } +} diff --git a/superwall/src/main/java/com/superwall/sdk/paywall/view/PaywallView.kt b/superwall/src/main/java/com/superwall/sdk/paywall/view/PaywallView.kt index fdd6f0d1..dd616224 100644 --- a/superwall/src/main/java/com/superwall/sdk/paywall/view/PaywallView.kt +++ b/superwall/src/main/java/com/superwall/sdk/paywall/view/PaywallView.kt @@ -35,6 +35,7 @@ import com.superwall.sdk.models.paywall.Paywall import com.superwall.sdk.models.paywall.PaywallPresentationStyle import com.superwall.sdk.models.triggers.TriggerRuleOccurrence import com.superwall.sdk.network.device.DeviceHelper +import com.superwall.sdk.paywall.archive.models.DecompressedWebArchive import com.superwall.sdk.paywall.manager.PaywallCacheLogic import com.superwall.sdk.paywall.manager.PaywallViewCache import com.superwall.sdk.paywall.presentation.PaywallCloseReason @@ -765,16 +766,41 @@ class PaywallView( } else { webView.settings.cacheMode = WebSettings.LOAD_DEFAULT } - if (useMultipleUrls) { - webView.loadPaywallWithFallbackUrl(paywall) - } else { - webView.loadUrl(url.value) + + when { + factory.webArchive().checkIfArchived(paywall.identifier) -> { + loadFromArchive(factory.webArchive().loadArchive(paywall.identifier)) + } + + useMultipleUrls -> { + webView.loadPaywallWithFallbackUrl(paywall) + } + + else -> { + webView.loadUrl(url.value) + } } } loadingState = PaywallLoadingState.LoadingURL() } } + fun loadFromArchive(archive: Result) { + archive.fold(onSuccess = { + mainScope.launch { + webView.loadFromArchive(it) + } + }, onFailure = { + webView.loadUrl(paywall.url.value) + Logger.debug( + logLevel = LogLevel.error, + scope = LogScope.paywallView, + message = "Failed to load archive: ${it.localizedMessage}", + error = it, + ) + }) + } + private fun recreateWebview() { removeView(webView) _webView = diff --git a/superwall/src/main/java/com/superwall/sdk/paywall/view/webview/DefaultWebviewClient.kt b/superwall/src/main/java/com/superwall/sdk/paywall/view/webview/DefaultWebviewClient.kt index a2a61116..994e8eb0 100644 --- a/superwall/src/main/java/com/superwall/sdk/paywall/view/webview/DefaultWebviewClient.kt +++ b/superwall/src/main/java/com/superwall/sdk/paywall/view/webview/DefaultWebviewClient.kt @@ -81,6 +81,9 @@ internal open class DefaultWebviewClient( request: WebResourceRequest?, error: WebResourceError, ) { + if (request?.url?.toString()?.contains("favicon.ico") == true) { + return + } ioScope.launch { if (request?.url?.toString()?.contains("runtime") == true) { val (code, desc) = diff --git a/superwall/src/main/java/com/superwall/sdk/paywall/view/webview/SWWebView.kt b/superwall/src/main/java/com/superwall/sdk/paywall/view/webview/SWWebView.kt index 1b2ff0ef..4240341c 100644 --- a/superwall/src/main/java/com/superwall/sdk/paywall/view/webview/SWWebView.kt +++ b/superwall/src/main/java/com/superwall/sdk/paywall/view/webview/SWWebView.kt @@ -28,6 +28,8 @@ import com.superwall.sdk.logger.Logger import com.superwall.sdk.misc.IOScope import com.superwall.sdk.misc.MainScope import com.superwall.sdk.models.paywall.Paywall +import com.superwall.sdk.paywall.archive.ArchiveWebClient +import com.superwall.sdk.paywall.archive.models.DecompressedWebArchive import com.superwall.sdk.paywall.presentation.PaywallInfo import com.superwall.sdk.paywall.view.delegate.PaywallLoadingState import com.superwall.sdk.paywall.view.webview.messaging.PaywallMessageHandler @@ -92,8 +94,10 @@ class SWWebView( webSettings.setSupportZoom(false) webSettings.builtInZoomControls = false webSettings.displayZoomControls = false - webSettings.allowFileAccess = false - webSettings.allowContentAccess = false + webSettings.allowFileAccess = true + webSettings.allowFileAccessFromFileURLs = true + webSettings.allowUniversalAccessFromFileURLs = true + webSettings.allowContentAccess = true webSettings.textZoom = 100 // Enable inline media playback, requires API level 17 if (Build.VERSION.SDK_INT >= Build.VERSION_CODES.JELLY_BEAN_MR1) { @@ -104,6 +108,23 @@ class SWWebView( this.webChromeClient = ChromeClient } + internal fun loadFromArchive(archiveFile: DecompressedWebArchive) { + val client = + ArchiveWebClient(archiveFile, onError = { + it.let { + throw IllegalStateException(it.description.toString() ?: "") + } + }) + this.webViewClient = client + lastLoadedUrl = url + prepareWebview() + if (Build.VERSION.SDK_INT < Build.VERSION_CODES.O) { + lastWebViewClient = client + } + listenToWebviewClientEvents(client) + super.loadUrl(transformUri(ArchiveWebClient.OVERRIDE_PATH)) + } + internal fun loadPaywallWithFallbackUrl(paywall: Paywall) { prepareWebview() val client = diff --git a/superwall/src/main/java/com/superwall/sdk/storage/Cache.kt b/superwall/src/main/java/com/superwall/sdk/storage/Cache.kt index 0033b99f..1fd24aec 100644 --- a/superwall/src/main/java/com/superwall/sdk/storage/Cache.kt +++ b/superwall/src/main/java/com/superwall/sdk/storage/Cache.kt @@ -11,6 +11,8 @@ import kotlinx.coroutines.CoroutineScope import kotlinx.coroutines.Dispatchers import kotlinx.coroutines.launch import kotlinx.serialization.json.Json +import java.io.FileInputStream +import java.io.FileOutputStream import kotlin.coroutines.CoroutineContext class Cache( @@ -103,6 +105,37 @@ class Cache( } } + fun readFile(storable: Storable): String? { + val file = storable.file(context = context) + return if (file.exists()) { + file.readText(Charsets.UTF_8) + } else { + null + } + } + + fun writeFile( + storable: Storable, + contents: String, + ): Boolean? { + val file = storable.file(context = context) + return try { + file.writeText(contents, Charsets.UTF_8) + true + } catch (e: Throwable) { + Logger.debug( + logLevel = LogLevel.info, + scope = LogScope.cache, + "Cannot write file ${file.path}", + ) + false + } + } + + fun getFileStream(storable: Storable): FileOutputStream = storable.file(context).outputStream() + + fun readFileStream(storable: Storable): FileInputStream = storable.file(context).inputStream() + //region Clean fun clean() { diff --git a/superwall/src/main/java/com/superwall/sdk/storage/CacheKeys.kt b/superwall/src/main/java/com/superwall/sdk/storage/CacheKeys.kt index 1b15d219..deddbaa5 100644 --- a/superwall/src/main/java/com/superwall/sdk/storage/CacheKeys.kt +++ b/superwall/src/main/java/com/superwall/sdk/storage/CacheKeys.kt @@ -310,6 +310,13 @@ internal object LatestRedemptionResponse : Storable { get() = WebRedemptionResponse.serializer() } +internal data class StoredWebArchive( + val payWallId: String, +) : Storable { + override val key: String = "store.webarchive.$payWallId" + override val directory: SearchPathDirectory = SearchPathDirectory.CACHE + override val serializer: KSerializer = String.serializer() +} //endregion // region Serializers diff --git a/superwall/src/main/java/com/superwall/sdk/storage/LocalStorage.kt b/superwall/src/main/java/com/superwall/sdk/storage/LocalStorage.kt index 0ff54715..a7d13444 100644 --- a/superwall/src/main/java/com/superwall/sdk/storage/LocalStorage.kt +++ b/superwall/src/main/java/com/superwall/sdk/storage/LocalStorage.kt @@ -18,6 +18,7 @@ import kotlinx.coroutines.Dispatchers import kotlinx.coroutines.launch import kotlinx.coroutines.runBlocking import kotlinx.serialization.json.Json +import java.io.FileInputStream import java.util.Date import kotlin.coroutines.CoroutineContext @@ -222,5 +223,18 @@ open class LocalStorage( cache.write(storable, data = data) } + override fun writeFile( + storable: Storable, + data: String, + ) { + cache.writeFile(storable, data) + } + + override fun getFileStream(storable: Storable) = cache.getFileStream(storable) + + override fun readFile(storable: Storable): String? = cache.readFile(storable) + + override fun readFileStream(storable: Storable): FileInputStream = cache.readFileStream(storable) + //endregion } diff --git a/superwall/src/main/java/com/superwall/sdk/storage/Storage.kt b/superwall/src/main/java/com/superwall/sdk/storage/Storage.kt index cc3c8d42..6b954800 100644 --- a/superwall/src/main/java/com/superwall/sdk/storage/Storage.kt +++ b/superwall/src/main/java/com/superwall/sdk/storage/Storage.kt @@ -1,5 +1,8 @@ package com.superwall.sdk.storage +import java.io.FileInputStream +import java.io.FileOutputStream + interface Storage { fun read(storable: Storable): T? @@ -8,8 +11,19 @@ interface Storage { data: T, ) + fun writeFile( + storable: Storable, + data: String, + ) + + fun getFileStream(storable: Storable): FileOutputStream + + fun readFile(storable: Storable): String? + fun delete(storable: Storable) { } + fun readFileStream(storable: Storable): FileInputStream = throw NotImplementedError("") + fun clean() } diff --git a/superwall/src/main/java/com/superwall/sdk/store/Entitlements.kt b/superwall/src/main/java/com/superwall/sdk/store/Entitlements.kt index af1126a6..00459743 100644 --- a/superwall/src/main/java/com/superwall/sdk/store/Entitlements.kt +++ b/superwall/src/main/java/com/superwall/sdk/store/Entitlements.kt @@ -112,7 +112,9 @@ class Entitlements( } is SubscriptionStatus.Inactive -> { + val withoutActive = backingActive.subtract(_activeDeviceEntitlements) _activeDeviceEntitlements.clear() + backingActive = withoutActive _inactive.clear() _status.value = value } diff --git a/superwall/src/main/java/com/superwall/sdk/utilities/ErrorTracking.kt b/superwall/src/main/java/com/superwall/sdk/utilities/ErrorTracking.kt index 30a74709..687c40ce 100644 --- a/superwall/src/main/java/com/superwall/sdk/utilities/ErrorTracking.kt +++ b/superwall/src/main/java/com/superwall/sdk/utilities/ErrorTracking.kt @@ -123,6 +123,7 @@ internal fun Superwall.trackError(e: Throwable) { try { dependencyContainer.errorTracker.trackError(e) } catch (e: Exception) { + e.printStackTrace() Logger.debug( com.superwall.sdk.logger.LogLevel.error, com.superwall.sdk.logger.LogScope.all, @@ -135,6 +136,7 @@ internal inline fun withErrorTracking(block: () -> T): Either try { Either.Success(block()) } catch (e: Throwable) { + e.printStackTrace() if (e.shouldLog()) { if (Superwall.initialized) { Superwall.instance.trackError(e) diff --git a/superwall/src/test/java/com/superwall/sdk/paywall/archive/CompressedWebArchiveTest.kt b/superwall/src/test/java/com/superwall/sdk/paywall/archive/CompressedWebArchiveTest.kt new file mode 100644 index 00000000..625b702a --- /dev/null +++ b/superwall/src/test/java/com/superwall/sdk/paywall/archive/CompressedWebArchiveTest.kt @@ -0,0 +1,408 @@ +package com.superwall.sdk.paywall.archive + +import com.superwall.sdk.Given +import com.superwall.sdk.Then +import com.superwall.sdk.When +import com.superwall.sdk.paywall.archive.models.ArchivePart +import io.mockk.every +import io.mockk.mockk +import org.junit.Before +import org.junit.Test + +class CompressedWebArchiveTest { + private lateinit var encoder: ArchiveEncoder + private lateinit var compressor: StringArchiveCompressor + + @Before + fun setup() { + encoder = mockk() + compressor = StringArchiveCompressor(encoder) + } + + @Test + fun test_compress_to_archive_valid() { + Given("a document and resources") { + val documentContent = "Hello".toByteArray() + val resourceContent = "body { color: red; }".toByteArray() + val document = + ArchivePart.Document( + url = "https://example.com/index.html", + mimeType = "text/html", + content = documentContent, + ) + val resource = + ArchivePart.Resource( + url = "https://example.com/style.css", + mimeType = "text/css", + content = resourceContent, + ) + every { encoder.encode(documentContent) } returns "ENCODED_HTML" + every { encoder.encode(resourceContent) } returns "ENCODED_CSS" + + val parts = listOf(document, resource) + val url = "https://example.com/index.html" + + When("compressing") { + val archive = compressor.compressToArchive(url, parts) + + Then("output is valid multipart HTML") { + // Check boundary + val boundaryRegex = Regex("----MultipartBoundary--[a-f0-9]+----") + assert(boundaryRegex.containsMatchIn(archive)) + // Check headers + assert(archive.contains("MIME-Version: 1.0")) + assert(archive.contains("Content-Type: multipart/related")) + // Check encoded content + assert(archive.contains("ENCODED_HTML")) + assert(archive.contains("ENCODED_CSS")) + // Document should come before resource + val docIndex = archive.indexOf("ENCODED_HTML") + val resIndex = archive.indexOf("ENCODED_CSS") + assert(docIndex in 0 until resIndex) + } + } + } + } + + @Test + fun test_compress_to_archive_empty() { + Given("an empty list") { + val parts = emptyList() + val url = "https://example.com/index.html" + + When("compressing") { + val archive = compressor.compressToArchive(url, parts) + + Then("output is a valid (empty) archive") { + // Check boundary + val boundaryRegex = Regex("----MultipartBoundary--[a-f0-9]+----") + assert(boundaryRegex.containsMatchIn(archive)) + // Check headers + assert(archive.contains("MIME-Version: 1.0")) + assert(archive.contains("Content-Type: multipart/related")) + // Should not contain any encoded content + assert(!archive.contains("ENCODED_HTML")) + assert(!archive.contains("ENCODED_CSS")) + } + } + } + } + + @Test + fun test_decompress_archive_valid() { + Given("a valid archive (doc + resources)") { + val documentContent = "Hello".toByteArray() + val resourceContent = "body { color: red; }".toByteArray() + val document = + ArchivePart.Document( + url = "https://example.com/index.html", + mimeType = "text/html", + content = documentContent, + ) + val resource = + ArchivePart.Resource( + url = "https://example.com/style.css", + mimeType = "text/css", + content = resourceContent, + ) + every { encoder.encode(documentContent) } returns "ENCODED_HTML" + every { encoder.encode(resourceContent) } returns "ENCODED_CSS" + every { encoder.decodeDefault("ENCODED_HTML") } returns documentContent + every { encoder.decodeDefault("ENCODED_CSS") } returns resourceContent + + val parts = listOf(document, resource) + val url = "https://example.com/index.html" + val archive = compressor.compressToArchive(url, parts) + + When("decompressing") { + val decompressed = compressor.decompressArchive(archive) + + Then("output matches original parts") { + assert(decompressed.content.size == 2) + val doc = decompressed.content.find { it is ArchivePart.Document } as ArchivePart.Document + val res = decompressed.content.find { it is ArchivePart.Resource } as ArchivePart.Resource + assert(doc != null) + assert(res != null) + assert(doc.url == document.url) + assert(doc.mimeType == document.mimeType) + assert(doc.content.contentEquals(document.content)) + assert(res.url == resource.url) + assert(res.mimeType == resource.mimeType) + assert(res.content.contentEquals(resource.content)) + } + } + } + } + + @Test + fun test_decompress_archive_only_document() { + Given("an archive with only a document") { + val documentContent = "Only Doc".toByteArray() + val document = + ArchivePart.Document( + url = "https://example.com/index.html", + mimeType = "text/html", + content = documentContent, + ) + every { encoder.encode(documentContent) } returns "ENCODED_ONLY_DOC" + every { encoder.decodeDefault("ENCODED_ONLY_DOC") } returns documentContent + + val parts = listOf(document) + val url = "https://example.com/index.html" + val archive = compressor.compressToArchive(url, parts) + + When("decompressing") { + val decompressed = compressor.decompressArchive(archive) + + Then("output contains only the document") { + assert(decompressed.content.size == 1) + val doc = decompressed.content.first() as ArchivePart.Document + assert(doc != null) + assert(doc.url == document.url) + assert(doc.mimeType == document.mimeType) + assert(doc.content.contentEquals(document.content)) + } + } + } + } + + @Test + fun test_decompress_archive_various_encodings() { + Given("archive with base64 and quoted-printable") { + val textContent = "Text".toByteArray() + val binaryContent = byteArrayOf(0x01, 0x02, 0x03, 0x04) + val document = + ArchivePart.Document( + url = "https://example.com/index.html", + mimeType = "text/html", + content = textContent, + ) + val resource = + ArchivePart.Resource( + url = "https://example.com/image.png", + mimeType = "image/png", + content = binaryContent, + ) + every { encoder.encode(textContent) } returns "QUOTED_PRINTABLE_TEXT" + every { encoder.encode(binaryContent) } returns "BASE64_BINARY" + every { encoder.decodeDefault("QUOTED_PRINTABLE_TEXT") } returns textContent + every { encoder.decodeDefault("BASE64_BINARY") } returns binaryContent + + val parts = listOf(document, resource) + val url = "https://example.com/index.html" + val archive = compressor.compressToArchive(url, parts) + + When("decompressing") { + val decompressed = compressor.decompressArchive(archive) + + Then("content is decoded") { + assert(decompressed.content.size == 2) + val doc = decompressed.content.find { it is ArchivePart.Document } as ArchivePart.Document + val res = decompressed.content.find { it is ArchivePart.Resource } as ArchivePart.Resource + assert(doc != null) + assert(res != null) + assert(doc.content.contentEquals(textContent)) + assert(res.content.contentEquals(binaryContent)) + } + } + } + } + + @Test + fun test_decompress_archive_malformed() { + Given("malformed archive") { + val malformedArchive = + """ + From: + MIME-Version: 1.0 + Subject: Superwall Web Archive + Snapshot-Content-Location: https://example.com/index.html + Content-Type: multipart/related;type=\"text/html\" + + --MISSING-BOUNDARY + Content-Type: text/html + Content-Location: https://example.com/index.html + Content-Id:
+ + Malformed + """.trimIndent() + + When("decompressing") { + val decompressed = compressor.decompressArchive(malformedArchive) + + Then("throws or handles gracefully") { + // Should not throw, should return empty parts + assert(decompressed.content.isEmpty()) + } + } + } + } + + @Test + fun test_create_multipart_html_order_and_boundary() { + Given("parts") { + val documentContent = "Order".toByteArray() + val resourceContent = "body { color: blue; }".toByteArray() + val document = + ArchivePart.Document( + url = "https://example.com/index.html", + mimeType = "text/html", + content = documentContent, + ) + val resource = + ArchivePart.Resource( + url = "https://example.com/style.css", + mimeType = "text/css", + content = resourceContent, + ) + every { encoder.encode(documentContent) } returns "DOC_CONTENT" + every { encoder.encode(resourceContent) } returns "RES_CONTENT" + + val parts = listOf(resource, document) // Intentionally out of order + val url = "https://example.com/index.html" + + When("creating multipart HTML") { + val archive = parts.createMultipartHTML(url, encoder) + + Then("doc is first and boundary is correct") { + // Check boundary + val boundaryRegex = Regex("----MultipartBoundary--[a-f0-9]+----") + assert(boundaryRegex.containsMatchIn(archive)) + // Document should come before resource + val docIndex = archive.indexOf("DOC_CONTENT") + val resIndex = archive.indexOf("RES_CONTENT") + assert(docIndex in 0 until resIndex) + } + } + } + } + + @Test + fun test_extract_header_correctness() { + Given("string with headers and content") { + val headerString = + """ + Content-Type: text/html + Content-Location: https://example.com/index.html + Content-Id:
+ + HeaderTest + """.trimIndent() + + When("extracting") { + val (headers, content) = headerString.extractHeader() + + Then("correct map and content") { + assert(headers["Content-Type"] == "text/html") + assert(headers["Content-Location"] == "https://example.com/index.html") + assert(headers["Content-Id"] == "
") + assert(content.trim() == "HeaderTest") + } + } + } + } + + @Test + fun test_extract_header_with_whitespace() { + Given("string with whitespace") { + val headerString = + """ + Content-Type: text/html + Content-Location: https://example.com/index.html + Content-Id:
+ + + WhitespaceTest + """.trimIndent() + + When("extracting") { + val (headers, content) = headerString.extractHeader() + + Then("parses correctly") { + println("$headers") + assert(headers["Content-Type"] == "text/html") + assert(headers["Content-Location"] == "https://example.com/index.html") + assert(headers["Content-Id"] == "
") + assert(content.trim() == "WhitespaceTest") + } + } + } + } + + @Test + fun test_to_mime_part_document() { + Given("document part") { + val documentContent = "MimeDoc".toByteArray() + val document = + ArchivePart.Document( + url = "https://example.com/index.html", + mimeType = "text/html", + content = documentContent, + ) + every { encoder.encode(documentContent) } returns "ENCODED_DOC" + + When("converting") { + val mimePart = document.toMimePart(encoder) + + Then("correct headers/content") { + assert(mimePart.contains("Content-Type: text/html")) + assert(mimePart.contains("Content-Location: https://example.com/index.html")) + assert(mimePart.contains("Content-Id: ${document.contentId}")) + assert(mimePart.contains("ENCODED_DOC")) + } + } + } + } + + @Test + fun test_to_mime_part_resource_text() { + Given("resource part (text)") { + val resourceContent = "body { color: green; }".toByteArray() + val resource = + ArchivePart.Resource( + url = "https://example.com/style.css", + mimeType = "text/css", + content = resourceContent, + ) + every { encoder.encode(resourceContent) } returns "ENCODED_TEXT_RES" + + When("converting") { + val mimePart = resource.toMimePart(encoder) + + Then("quoted-printable encoding") { + assert(mimePart.contains("Content-Type: text/css")) + assert(mimePart.contains("Content-Location: https://example.com/style.css")) + assert(mimePart.contains("Content-Id: ${resource.contentId}")) + assert(mimePart.contains("ENCODED_TEXT_RES")) + assert(mimePart.contains("Content-Transfer-Encoding: quoted-printable")) + } + } + } + } + + @Test + fun test_to_mime_part_resource_binary() { + Given("resource part (binary)") { + val resourceContent = byteArrayOf(0x10, 0x20, 0x30, 0x40) + val resource = + ArchivePart.Resource( + url = "https://example.com/image.png", + mimeType = "image/png", + content = resourceContent, + ) + every { encoder.encode(resourceContent) } returns "ENCODED_BINARY_RES" + + When("converting") { + val mimePart = resource.toMimePart(encoder) + + Then("base64 encoding") { + assert(mimePart.contains("Content-Type: image/png")) + assert(mimePart.contains("Content-Location: https://example.com/image.png")) + assert(mimePart.contains("Content-Id: ${resource.contentId}")) + assert(mimePart.contains("ENCODED_BINARY_RES")) + assert(mimePart.contains("Content-Transfer-Encoding: base64")) + } + } + } + } +} diff --git a/superwall/src/test/java/com/superwall/sdk/paywall/archive/ManifestDownloaderTest.kt b/superwall/src/test/java/com/superwall/sdk/paywall/archive/ManifestDownloaderTest.kt new file mode 100644 index 00000000..b74a0a2c --- /dev/null +++ b/superwall/src/test/java/com/superwall/sdk/paywall/archive/ManifestDownloaderTest.kt @@ -0,0 +1,37 @@ +package com.superwall.sdk.paywall.archive + +import android.util.Base64 +import io.mockk.mockk +import org.junit.Test +import kotlin.io.encoding.ExperimentalEncodingApi + +class ManifestDownloaderTest { + val downloader = ManifestDownloader(mockk(), mockk()) + + @OptIn(ExperimentalEncodingApi::class) + @Test + fun extractAbsoluteUrls() { + val content = + kotlin.io.encoding.Base64 + .decode(testDoc) + .toString(Charsets.UTF_8) + val abs = downloader.discoverAbsoluteResources(content) + val rel = downloader.discoverRelativeResources(content) + println(abs.size) + assert(abs.size > 1) + abs.forEach { + println("Abs resource ${it.key}") + } + + println(rel.size) + rel.forEach { + println("Rel resource ${it.key}") + } + assert(rel.size > 1) + } +} + +val testDoc = + """ + <!DOCTYPE html>
<html lang="en">

<head>
  <meta charset='utf-8'>
  <meta name='viewport' content='width=device-width,initial-scale=1'>
  <title>Superwall Paywall Template</title>
  <link rel='icon' type='image/png' href='../public/assets/favicon.png'>
  <link href="../public/assets/favicon_256.png" rel="apple-touch-icon">
  <link href="../public/assets/favicon.png" rel="shortcut icon" type="image/x-icon">

  <script>
    if (new URL(document.location).searchParams.has('logrocket')) {
  
      try {
        // Enable debug logging
        localStorage.debug = '*'
      } catch (e) {

      }

      // Create the LogRocket script element
      var script1 = document.createElement("script");
      script1.src = "https://cdn.ingest-lr.com/LogRocket.min.js";
      script1.setAttribute("crossorigin", "anonymous");
      script1.onload = function() {
          // Initialize LogRocket once the script has loaded
          if (window.LogRocket) {
            window.LogRocket.init('77orxm/paywalls');
          }
      };

      // Append the script element to the document's head
      document.head.appendChild(script1);

    }
  </script>

  <script>
    var exports = {};
  </script>
  <link rel='stylesheet' href='../public/css/global.css'>
  <link rel='stylesheet' href='build/bundle.css'>
  <script defer src='build/bundle.js'></script>

  <script>
    if (window.location.hostname.includes('superwall') && !(new URL(document.location)).searchParams.has('debug')) {
      window.console.log = () => { }
    } else {
      console.log("\n\n\n---------------------------\nPAYWALLUI: DEBUGGER ENABLED\n---------------------------\n\n\n")
    }
  </script>

</head>

<body>
  <div id="swWidgetContainer" class="sw-widget-container">

      <script>
        window.Superwall = {}
        window.Superwall.didConfigure = false
        window.Superwall.observerHandler = null
        window.Superwall.observer = null
        window.Superwall.updatePaywallContainerPadding = null

        window.Superwall.configure = (options, darkOptions) => {
          if (window.Superwall.didConfigure) {
            return
          }

          configure(options, darkOptions)
          // setupPjsAndDom()
          window.Superwall.didConfigure = true
        }

        window.Superwall.reconfigure = (option, darkOptions) => {
          configure(option, darkOptions)
        }

        /* __SUPERWALL_REPLACE_START__ */
window._paywall_js_paywall = '{"substitutions":[{"key":"close-1","value":"","skipInnerHTML":true,"tagName":"img","subType":"img","properties":[{"prefix":"default","property":{"type":"click-behavior","clickBehavior":{"type":"close"}}},{"prefix":"default","property":{"type":"src","src":"../public/assets/nav-button.svg","srcSet":[""]}}]},{"key":"close-2","value":"left","skipInnerHTML":false,"tagName":"div","subType":"var","properties":[{"prefix":"default","property":{"type":"click-behavior","clickBehavior":{"type":"close"}}}]},{"key":"close-3","value":"right","skipInnerHTML":false,"tagName":"div","subType":"var","properties":[{"prefix":"default","property":{"type":"click-behavior","clickBehavior":{"type":"close"}}}]},{"key":"close-4","value":"","skipInnerHTML":true,"tagName":"img","subType":"img","properties":[{"prefix":"default","property":{"type":"click-behavior","clickBehavior":{"type":"close"}}},{"prefix":"default","property":{"type":"src","src":"https://static.superwallassets.com/PpVQle7e92piP--7mVy1X","srcSet":[]}},{"prefix":"default","property":{"type":"styles","styles":[{"property":"opacity","value":"1"}]}}],"revision":1705516429893},{"key":"navbar","value":"","skipInnerHTML":true,"tagName":"div","subType":"var","properties":[],"revision":1705518685220},{"key":"Nav Left Inner Icon","value":"","skipInnerHTML":true,"tagName":"img","subType":"img","properties":[{"prefix":"default","property":{"type":"src","src":"../public/assets/nav-button.svg","srcSet":[""]}}]},{"key":"Nav Left Inner","value":"extra","skipInnerHTML":false,"tagName":"div","subType":"var","properties":[]},{"key":"Logo","value":"","skipInnerHTML":true,"tagName":"img","subType":"img","properties":[{"prefix":"default","property":{"type":"src","src":"../public/assets/logo.svg","srcSet":[""]}}]},{"key":"Nav Middle","value":"Title","skipInnerHTML":false,"tagName":"div","subType":"var","properties":[]},{"key":"Nav Right Inner","value":"extra","skipInnerHTML":false,"tagName":"div","subType":"var","properties":[]},{"key":"Nav Right Inner Icon","value":"","skipInnerHTML":true,"tagName":"img","subType":"img","properties":[{"prefix":"default","property":{"type":"src","src":"../public/assets/nav-button.svg","srcSet":[""]}}]},{"key":"purchase-primary","value":"","skipInnerHTML":true,"tagName":"div","subType":"var","properties":[{"prefix":"default","property":{"type":"click-behavior","clickBehavior":{"type":"purchase","product":"primary"}}},{"prefix":"default","property":{"type":"styles","styles":[{"property":"height","value":"48px"}]}}]},{"key":"purchase-secondary","value":"","skipInnerHTML":true,"tagName":"div","subType":"var","properties":[{"prefix":"default","property":{"type":"click-behavior","clickBehavior":{"type":"purchase","product":"secondary"}}},{"prefix":"default","property":{"type":"styles","styles":[{"property":"height","value":"48px"}]}}]},{"key":"purchase-tertiary","value":"","skipInnerHTML":true,"tagName":"div","subType":"var","properties":[{"prefix":"default","property":{"type":"click-behavior","clickBehavior":{"type":"purchase","product":"tertiary"}}},{"prefix":"default","property":{"type":"styles","styles":[{"property":"height","value":"48px"}]}}]},{"key":"Section __sw-d43-mde0xyrshspgsp7_g","value":"","skipInnerHTML":true,"tagName":"div","subType":"var","properties":[{"prefix":"default","property":{"type":"styles","styles":[{"property":"padding-top","value":"24px"},{"property":"padding-bottom","value":"48px"},{"property":"padding-left","value":"16px"},{"property":"padding-right","value":"16px"},{"property":"display","value":"none"}]}}],"revision":1705517301048},{"key":"Div __sw-bus0t4-o-fj5po1fl9vkj","value":"","skipInnerHTML":true,"tagName":"div","subType":"var","properties":[{"prefix":"default","property":{"type":"backgroundImage","backgroundImage":"none","backgroundSize":"cover","backgroundRepeat":"no-repeat","backgroundPosition":"center"}},{"prefix":"default","property":{"type":"styles","styles":[{"property":"position","value":"relative"},{"property":"width","value":"100%"},{"property":"padding-top","value":"56px"},{"property":"padding-left","value":"16px"},{"property":"padding-right","value":"16px"}]}}],"initialStyles":{},"revision":1705518358350},{"key":"ImageBase __sw-jowhuuamkeaz22mrxolrk","value":"","skipInnerHTML":true,"tagName":"img","subType":"img","properties":[{"prefix":"default","property":{"type":"src","src":"https://static.superwallassets.com/Lk-TIJDEE3wlSfp47vmCC","srcSet":[]}},{"prefix":"default","property":{"type":"styles","styles":[{"property":"width","value":"100%"},{"property":"height","value":"auto"},{"property":"margin-top","value":"20px"},{"property":"margin-left","value":"auto"},{"property":"margin-right","value":"auto"}]}}],"initialStyles":{"width":"100%","height":"auto"},"revision":1705518021971},{"key":"Text __sw-pfrcx444pq9vwjzhuthah","value":"Compare Plans and Features","skipInnerHTML":false,"tagName":"p","subType":"var","properties":[{"prefix":"default","property":{"type":"styles","styles":[{"property":"font-size","value":"1rem"},{"property":"font-weight","value":"600"},{"property":"line-height","value":"140%"},{"property":"text-align","value":"center"},{"property":"margin-bottom","value":"16px"}]}}],"initialStyles":{},"revision":1705517290402},{"key":"Div __sw-4fdtiztnlzlpspxonfmob","value":"","skipInnerHTML":true,"tagName":"div","subType":"var","properties":[{"prefix":"default","property":{"type":"styles","styles":[{"property":"display","value":"flex"},{"property":"align-items","value":"stretch"},{"property":"justify-content","value":"center"},{"property":"gap","value":"8px"}]}}],"initialStyles":{}},{"key":"Div __sw-qxdxpughnguoib0zwuk7f","value":"","skipInnerHTML":true,"tagName":"div","subType":"var","properties":[{"prefix":"default","property":{"type":"styles","styles":[{"property":"display","value":"flex"},{"property":"flex-direction","value":"column"},{"property":"gap","value":"8px"},{"property":"text-align","value":"center"},{"property":"width","value":"100%"}]}}],"initialStyles":{}},{"key":"Text __sw-3jyjadimqyqgdahhzyosa","value":"Starter","skipInnerHTML":false,"tagName":"p","subType":"var","properties":[{"prefix":"default","property":{"type":"styles","styles":[{"property":"font-size","value":"20px"},{"property":"font-weight","value":"700"},{"property":"line-height","value":"110%"}]}}],"initialStyles":{}},{"key":"Div __sw-eemdkqxnkklno-qmwe9bj","value":"","skipInnerHTML":true,"tagName":"div","subType":"var","properties":[{"prefix":"default","property":{"type":"click-behavior","clickBehavior":{"type":"purchase","product":"tertiary"}}},{"prefix":"default","property":{"type":"styles","styles":[{"property":"font-size","value":"1rem"},{"property":"background-color","value":"hsl(216, 54%, 95%)"},{"property":"width","value":"100%"},{"property":"padding-top","value":"8px"},{"property":"padding-bottom","value":"13px"},{"property":"border-top-left-radius","value":"20px"},{"property":"border-top-right-radius","value":"20px"},{"property":"border-bottom-left-radius","value":"20px"},{"property":"border-bottom-right-radius","value":"20px"},{"property":"border-width","value":"2px"},{"property":"border-color","value":"hsl(216, 54%, 95%)"},{"property":"border-style","value":"solid"}]}}],"initialStyles":{}},{"key":"Text __sw-tgvzw1eipdcc-aq6uyda-","value":"{{tertiary.periodMonths}}","skipInnerHTML":false,"tagName":"p","subType":"var","properties":[{"prefix":"default","property":{"type":"styles","styles":[{"property":"font-size","value":"1rem"},{"property":"font-weight","value":"700"},{"property":"line-height","value":"110%"}]}}],"initialStyles":{}},{"key":"Text __sw-vvrkiglocy3rqpgfb2dws","value":"month","skipInnerHTML":false,"tagName":"p","subType":"var","properties":[{"prefix":"default","property":{"type":"styles","styles":[{"property":"font-size","value":"11px"},{"property":"font-weight","value":"700"},{"property":"line-height","value":"110%"},{"property":"margin-bottom","value":"2px"}]}}],"initialStyles":{}},{"key":"Text __sw-b_ksu4qwfxndzniuvs3c1","value":"billed now","skipInnerHTML":false,"tagName":"p","subType":"var","properties":[{"prefix":"default","property":{"type":"styles","styles":[{"property":"font-size","value":"8px"},{"property":"font-weight","value":"400"},{"property":"line-height","value":"110%"},{"property":"margin-bottom","value":"7px"}]}}],"initialStyles":{}},{"key":"Text __sw-4lxchaf6g1w8umsfeuwfp","value":"{{tertiary.price}}","skipInnerHTML":false,"tagName":"p","subType":"var","properties":[{"prefix":"default","property":{"type":"styles","styles":[{"property":"font-size","value":"18px"},{"property":"font-weight","value":"700"},{"property":"line-height","value":"110%"},{"property":"margin-bottom","value":"2px"}]}}],"initialStyles":{}},{"key":"Text __sw--pgdty5qy4ctnvr9hg1qk","value":"3-day trial","skipInnerHTML":false,"tagName":"p","subType":"var","properties":[{"prefix":"default","property":{"type":"styles","styles":[{"property":"font-size","value":"10px"},{"property":"font-weight","value":"700"},{"property":"line-height","value":"110%"},{"property":"margin-bottom","value":"13px"}]}}],"initialStyles":{},"revision":1701420872512},{"key":"Div __sw-z9puwooywnxilszj5jtrm","value":"","skipInnerHTML":true,"tagName":"div","subType":"var","properties":[{"prefix":"default","property":{"type":"styles","styles":[{"property":"background-color","value":"hsla(220, 26%, 59%, 0.6)"},{"property":"height","value":"2px"},{"property":"margin-bottom","value":"8px"}]}}],"initialStyles":{}},{"key":"Text __sw-msxk1uzuaboxo_76g-eyd","value":"{{tertiary.monthlyPrice}}","skipInnerHTML":false,"tagName":"p","subType":"var","properties":[{"prefix":"default","property":{"type":"styles","styles":[{"property":"font-size","value":"16px"},{"property":"font-weight","value":"700"},{"property":"line-height","value":"110%"},{"property":"margin-bottom","value":"2px"}]}}],"initialStyles":{}},{"key":"Text __sw-senqo-ti5kc25vo0k5ojt","value":"per month","skipInnerHTML":false,"tagName":"p","subType":"var","properties":[{"prefix":"default","property":{"type":"styles","styles":[{"property":"font-size","value":"8px"},{"property":"line-height","value":"140%"}]}}],"initialStyles":{}},{"key":"Text __sw-rccfrlcvhykvuc_y17glm","value":"&nbsp;","skipInnerHTML":false,"tagName":"p","subType":"var","properties":[{"prefix":"default","property":{"type":"styles","styles":[{"property":"font-size","value":"11px"},{"property":"line-height","value":"140%"}]}}],"initialStyles":{}},{"key":"Div __sw-ghgnh_kni_mgcrxr7wsgt","value":"","skipInnerHTML":true,"tagName":"div","subType":"var","properties":[{"prefix":"default","property":{"type":"styles","styles":[{"property":"display","value":"flex"},{"property":"flex-direction","value":"column"},{"property":"gap","value":"8px"},{"property":"text-align","value":"center"},{"property":"width","value":"100%"}]}}],"initialStyles":{}},{"key":"Text __sw--4dw1pmc2qbx96jkvhldl","value":"Starter","skipInnerHTML":false,"tagName":"p","subType":"var","properties":[{"prefix":"default","property":{"type":"styles","styles":[{"property":"font-size","value":"20px"},{"property":"font-weight","value":"700"},{"property":"line-height","value":"110%"}]}}],"initialStyles":{}},{"key":"Div __sw-3aeplzh0xxvuk0mcuj2mv","value":"","skipInnerHTML":true,"tagName":"div","subType":"var","properties":[{"prefix":"default","property":{"type":"click-behavior","clickBehavior":{"type":"purchase","product":"secondary"}}},{"prefix":"default","property":{"type":"styles","styles":[{"property":"font-size","value":"1rem"},{"property":"background-color","value":"rgba(123, 141, 177, 0.08)"},{"property":"width","value":"100%"},{"property":"padding-top","value":"8px"},{"property":"padding-bottom","value":"13px"},{"property":"border-top-left-radius","value":"20px"},{"property":"border-top-right-radius","value":"20px"},{"property":"border-bottom-left-radius","value":"20px"},{"property":"border-bottom-right-radius","value":"20px"},{"property":"border-width","value":"2px"},{"property":"border-color","value":"hsla(220, 98%, 63%, 1)"},{"property":"border-style","value":"solid"}]}}],"initialStyles":{}},{"key":"Text __sw-v1agx52sqhfh_leaplh55","value":"{{secondary.periodMonths}}","skipInnerHTML":false,"tagName":"p","subType":"var","properties":[{"prefix":"default","property":{"type":"styles","styles":[{"property":"font-size","value":"1rem"},{"property":"font-weight","value":"700"},{"property":"line-height","value":"110%"}]}}],"initialStyles":{}},{"key":"Text __sw-v2kx_wjvwcsw2pqzp4qib","value":"months","skipInnerHTML":false,"tagName":"p","subType":"var","properties":[{"prefix":"default","property":{"type":"styles","styles":[{"property":"font-size","value":"11px"},{"property":"font-weight","value":"700"},{"property":"line-height","value":"110%"},{"property":"margin-bottom","value":"2px"}]}}],"initialStyles":{}},{"key":"Text __sw-h-hdzhmaekkt9l6v0hyog","value":"billed now","skipInnerHTML":false,"tagName":"p","subType":"var","properties":[{"prefix":"default","property":{"type":"styles","styles":[{"property":"font-size","value":"8px"},{"property":"font-weight","value":"400"},{"property":"line-height","value":"110%"},{"property":"margin-bottom","value":"7px"}]}}],"initialStyles":{}},{"key":"Text __sw-qjmfqp59bdqi1mb4hmbnu","value":"{{secondary.price}}","skipInnerHTML":false,"tagName":"p","subType":"var","properties":[{"prefix":"default","property":{"type":"styles","styles":[{"property":"font-size","value":"18px"},{"property":"color","value":"hsla(220, 98%, 63%, 1)"},{"property":"font-weight","value":"700"},{"property":"line-height","value":"110%"},{"property":"margin-bottom","value":"2px"}]}}],"initialStyles":{}},{"key":"Text __sw-nzu3pxqbwhusv_9khiim7","value":"3-day trial","skipInnerHTML":false,"tagName":"p","subType":"var","properties":[{"prefix":"default","property":{"type":"styles","styles":[{"property":"font-size","value":"10px"},{"property":"font-weight","value":"700"},{"property":"line-height","value":"110%"},{"property":"margin-bottom","value":"13px"}]}}],"initialStyles":{},"revision":1701420871065},{"key":"Div __sw-zkkukwakhy9tmbhtj7so0","value":"","skipInnerHTML":true,"tagName":"div","subType":"var","properties":[{"prefix":"default","property":{"type":"styles","styles":[{"property":"background-color","value":"hsla(220, 98%, 63%, 1)"},{"property":"height","value":"2px"},{"property":"margin-bottom","value":"8px"}]}}],"initialStyles":{}},{"key":"Text __sw-7aesvue6zlcld9k-kkrf7","value":"{{secondary.monthlyPrice}}","skipInnerHTML":false,"tagName":"p","subType":"var","properties":[{"prefix":"default","property":{"type":"styles","styles":[{"property":"font-size","value":"17px"},{"property":"font-weight","value":"700"},{"property":"line-height","value":"110%"},{"property":"margin-bottom","value":"2px"}]}}],"initialStyles":{}},{"key":"Text __sw-gtocf_uibrqikc2yyorh4","value":"per month","skipInnerHTML":false,"tagName":"p","subType":"var","properties":[{"prefix":"default","property":{"type":"styles","styles":[{"property":"font-size","value":"8px"},{"property":"line-height","value":"140%"}]}}],"initialStyles":{}},{"key":"Text __sw-2e7maatqw5kmlbyb0en0e","value":"{% assign tertiary_weekly_price = tertiary.rawPrice | divided_by: tertiary.periodWeeks %}\n{% assign secondary_weekly_price = secondary.rawPrice | divided_by: secondary.periodWeeks %}\n{% assign difference = tertiary_weekly_price | minus: secondary_weekly_price %}\n{% assign percent_off = difference | times: 100 | divided_by: tertiary_weekly_price %}\n{% assign rounded_percent_off = percent_off | round: 0%}\nSAVE {{ rounded_percent_off }}%","skipInnerHTML":false,"tagName":"p","subType":"var","properties":[{"prefix":"default","property":{"type":"styles","styles":[{"property":"font-size","value":"11px"},{"property":"line-height","value":"140%"}]}}],"initialStyles":{},"revision":1701420904000},{"key":"Div __sw-hf1iqc3sy_pffhpx0b4vv","value":"","skipInnerHTML":true,"tagName":"div","subType":"var","properties":[{"prefix":"default","property":{"type":"styles","styles":[{"property":"display","value":"flex"},{"property":"flex-direction","value":"column"},{"property":"gap","value":"8px"},{"property":"text-align","value":"center"},{"property":"width","value":"100%"}]}}],"initialStyles":{}},{"key":"Text __sw-fb_-q_x5u6zd_4fk-hvoc","value":"AI Pro","skipInnerHTML":false,"tagName":"p","subType":"var","properties":[{"prefix":"default","property":{"type":"styles","styles":[{"property":"font-size","value":"20px"},{"property":"font-weight","value":"700"},{"property":"line-height","value":"110%"}]}}],"initialStyles":{}},{"key":"Div __sw-zig-5l9seb8kpgadw7bij","value":"","skipInnerHTML":true,"tagName":"div","subType":"var","properties":[{"prefix":"default","property":{"type":"click-behavior","clickBehavior":{"type":"purchase","product":"primary"}}},{"prefix":"default","property":{"type":"styles","styles":[{"property":"font-size","value":"1rem"},{"property":"background-color","value":"rgba(123, 141, 177, 0.08)"},{"property":"width","value":"100%"},{"property":"padding-top","value":"8px"},{"property":"padding-bottom","value":"13px"},{"property":"border-top-left-radius","value":"20px"},{"property":"border-top-right-radius","value":"20px"},{"property":"border-bottom-left-radius","value":"20px"},{"property":"border-bottom-right-radius","value":"20px"},{"property":"border-width","value":"2px"},{"property":"border-color","value":"hsl(320, 67%, 57%)"},{"property":"border-style","value":"solid"}]}}],"initialStyles":{}},{"key":"Text __sw-fsybkqczaa0iio8lpzc2y","value":"{{ primary.periodMonths }}","skipInnerHTML":false,"tagName":"p","subType":"var","properties":[{"prefix":"default","property":{"type":"styles","styles":[{"property":"font-size","value":"1rem"},{"property":"font-weight","value":"700"},{"property":"line-height","value":"110%"}]}}],"initialStyles":{}},{"key":"Text __sw-xb_r2rsy-8g18arae4v8s","value":"months","skipInnerHTML":false,"tagName":"p","subType":"var","properties":[{"prefix":"default","property":{"type":"styles","styles":[{"property":"font-size","value":"11px"},{"property":"font-weight","value":"700"},{"property":"line-height","value":"110%"},{"property":"margin-bottom","value":"2px"}]}}],"initialStyles":{}},{"key":"Text __sw-llwvx9m1-b1hj5cqnhy3j","value":"billed now","skipInnerHTML":false,"tagName":"p","subType":"var","properties":[{"prefix":"default","property":{"type":"styles","styles":[{"property":"font-size","value":"8px"},{"property":"font-weight","value":"400"},{"property":"line-height","value":"110%"},{"property":"margin-bottom","value":"7px"}]}}],"initialStyles":{}},{"key":"Text __sw-nyvy9yczkxypjaxs8egvq","value":"{{primary.price}}","skipInnerHTML":false,"tagName":"p","subType":"var","properties":[{"prefix":"default","property":{"type":"styles","styles":[{"property":"font-size","value":"18px"},{"property":"color","value":"hsl(320, 67%, 57%)"},{"property":"font-weight","value":"700"},{"property":"line-height","value":"110%"},{"property":"margin-bottom","value":"2px"}]}}],"initialStyles":{}},{"key":"Text __sw-gvggk098u8pvm83hfonhl","value":"3-day trial","skipInnerHTML":false,"tagName":"p","subType":"var","properties":[{"prefix":"default","property":{"type":"styles","styles":[{"property":"font-size","value":"10px"},{"property":"font-weight","value":"700"},{"property":"line-height","value":"110%"},{"property":"margin-bottom","value":"13px"}]}}],"initialStyles":{},"revision":1701420873448},{"key":"Div __sw-ogzwezxpr2wdecpom4aq9","value":"","skipInnerHTML":true,"tagName":"div","subType":"var","properties":[{"prefix":"default","property":{"type":"styles","styles":[{"property":"background-color","value":"hsl(320, 67%, 57%)"},{"property":"height","value":"2px"},{"property":"margin-bottom","value":"8px"}]}}],"initialStyles":{}},{"key":"Text __sw-dcavhay8qqn81xeqmbiqi","value":"{{primary.monthlyPrice}}","skipInnerHTML":false,"tagName":"p","subType":"var","properties":[{"prefix":"default","property":{"type":"styles","styles":[{"property":"font-size","value":"18px"},{"property":"font-weight","value":"700"},{"property":"line-height","value":"110%"},{"property":"margin-bottom","value":"2px"}]}}],"initialStyles":{}},{"key":"Text __sw-qwstewks3ceebl39k8vxl","value":"per month","skipInnerHTML":false,"tagName":"p","subType":"var","properties":[{"prefix":"default","property":{"type":"styles","styles":[{"property":"font-size","value":"8px"},{"property":"line-height","value":"140%"}]}}],"initialStyles":{}},{"key":"Text __sw-yygsr8zug8onmw_yttqus","value":"","skipInnerHTML":false,"tagName":"p","subType":"var","properties":[{"prefix":"default","property":{"type":"styles","styles":[{"property":"font-size","value":"11px"},{"property":"line-height","value":"140%"}]}}],"initialStyles":{}},{"key":"Section __sw-tkv5-4j-s6pzzbum2xpj-","value":"","skipInnerHTML":true,"tagName":"div","subType":"var","properties":[{"prefix":"default","property":{"type":"styles","styles":[{"property":"padding-bottom","value":"48px"},{"property":"padding-left","value":"16px"},{"property":"padding-right","value":"16px"}]}}],"revision":1705518715733},{"key":"Text __sw-rt--k-jsikututoywmf-b","value":"Create Videos 10x Faster","skipInnerHTML":false,"tagName":"p","subType":"var","properties":[{"prefix":"default","property":{"type":"styles","styles":[{"property":"font-size","value":"1rem"},{"property":"font-weight","value":"600"},{"property":"line-height","value":"140%"},{"property":"text-align","value":"center"},{"property":"margin-bottom","value":"16px"}]}}],"initialStyles":{}},{"key":"Div __sw-uqdbmrnhmzoug7tzytzgg","value":"","skipInnerHTML":true,"tagName":"div","subType":"var","properties":[{"prefix":"default","property":{"type":"styles","styles":[{"property":"display","value":"flex"},{"property":"align-items","value":"stretch"},{"property":"justify-content","value":"center"},{"property":"gap","value":"8px"}]}}],"initialStyles":{}},{"key":"Div __sw-_fizlsuwldvx44bresxi5","value":"","skipInnerHTML":true,"tagName":"div","subType":"var","properties":[{"prefix":"default","property":{"type":"styles","styles":[{"property":"text-align","value":"center"},{"property":"background-color","value":"rgba(255, 255, 255, 1)"},{"property":"width","value":"100%"},{"property":"padding-top","value":"16px"},{"property":"padding-bottom","value":"23px"},{"property":"padding-left","value":"8px"},{"property":"padding-right","value":"8px"},{"property":"border-top-left-radius","value":"20px"},{"property":"border-top-right-radius","value":"20px"},{"property":"border-bottom-left-radius","value":"20px"},{"property":"border-bottom-right-radius","value":"20px"}]}}],"initialStyles":{}},{"key":"Text __sw-exjbs2dv4nxujv1mi_i1z","value":"Free","skipInnerHTML":false,"tagName":"p","subType":"var","properties":[{"prefix":"default","property":{"type":"styles","styles":[{"property":"font-size","value":"12px"},{"property":"font-weight","value":"700"},{"property":"line-height","value":"15px"},{"property":"background-color","value":"rgba(68, 129, 253, 0.08)"},{"property":"margin-bottom","value":"2px"},{"property":"padding-top","value":"4px"},{"property":"padding-bottom","value":"4px"},{"property":"padding-left","value":"10px"},{"property":"padding-right","value":"10px"},{"property":"border-top-left-radius","value":"20px"},{"property":"border-top-right-radius","value":"20px"},{"property":"border-bottom-left-radius","value":"20px"},{"property":"border-bottom-right-radius","value":"20px"}]}}],"initialStyles":{}},{"key":"Div __sw-mo_rhlqht3lyfeu-1ekon","value":"","skipInnerHTML":true,"tagName":"div","subType":"var","properties":[{"prefix":"default","property":{"type":"styles","styles":[{"property":"display","value":"flex"},{"property":"flex-direction","value":"column"},{"property":"align-items","value":"center"},{"property":"justify-content","value":"flex-start"},{"property":"gap","value":"8px"},{"property":"margin-bottom","value":"12px"}]}}],"initialStyles":{}},{"key":"Div __sw-3aoj6ye-naxfemkb9-n-j","value":"","skipInnerHTML":true,"tagName":"div","subType":"var","properties":[{"prefix":"default","property":{"type":"styles","styles":[{"property":"display","value":"flex"},{"property":"flex-direction","value":"column"},{"property":"align-items","value":"center"},{"property":"justify-content","value":"center"},{"property":"background-color","value":"rgba(68, 129, 253, 0.08)"},{"property":"width","value":"93px"},{"property":"height","value":"93px"},{"property":"border-top-left-radius","value":"999px"},{"property":"border-top-right-radius","value":"999px"},{"property":"border-bottom-left-radius","value":"999px"},{"property":"border-bottom-right-radius","value":"999px"}]}}],"initialStyles":{}},{"key":"ImageBase __sw-tczxoqjxmdvti6yxx375f","value":"","skipInnerHTML":true,"tagName":"img","subType":"img","properties":[{"prefix":"default","property":{"type":"src","src":"https://static.superwallassets.com/LMbCJMM4kgLB1Zy7yWzIH","srcSet":[]}},{"prefix":"default","property":{"type":"styles","styles":[{"property":"width","value":"58px"},{"property":"height","value":"37px"}]}}],"initialStyles":{"width":"100%","height":"auto"}},{"key":"Text __sw-eb8qlg0abrnekon_llk-q","value":"Watermark","skipInnerHTML":false,"tagName":"p","subType":"var","properties":[{"prefix":"default","property":{"type":"styles","styles":[{"property":"font-size","value":"9px"},{"property":"line-height","value":"120%"},{"property":"margin-top","value":"5px"}]}}],"initialStyles":{}},{"key":"Div __sw-lq5_vageudanmtsf5v1vg","value":"","skipInnerHTML":true,"tagName":"div","subType":"var","properties":[{"prefix":"default","property":{"type":"styles","styles":[{"property":"display","value":"flex"},{"property":"flex-direction","value":"column"},{"property":"align-items","value":"center"},{"property":"justify-content","value":"center"},{"property":"background-color","value":"rgba(170, 88, 238, 0.08)"},{"property":"width","value":"93px"},{"property":"height","value":"93px"},{"property":"border-top-left-radius","value":"999px"},{"property":"border-top-right-radius","value":"999px"},{"property":"border-bottom-left-radius","value":"999px"},{"property":"border-bottom-right-radius","value":"999px"}]}}],"initialStyles":{}},{"key":"ImageBase __sw-1rmp4ktqjeb9efbuobh1i","value":"","skipInnerHTML":true,"tagName":"img","subType":"img","properties":[{"prefix":"default","property":{"type":"src","src":"https://static.superwallassets.com/Qx1wuxwanlG92i0DuAbaZ","srcSet":[]}},{"prefix":"default","property":{"type":"styles","styles":[{"property":"width","value":"48px"},{"property":"height","value":"48px"}]}}],"initialStyles":{"width":"100%","height":"auto"}},{"key":"Text __sw-eh9pzlm1duyvdn7-x3btj","value":"max length<br>per video","skipInnerHTML":false,"tagName":"p","subType":"var","properties":[{"prefix":"default","property":{"type":"styles","styles":[{"property":"font-size","value":"9px"},{"property":"line-height","value":"120%"},{"property":"margin-top","value":"5px"}]}}],"initialStyles":{}},{"key":"Div __sw-aizs9p1uzzv1rx_qdog78","value":"","skipInnerHTML":true,"tagName":"div","subType":"var","properties":[{"prefix":"default","property":{"type":"styles","styles":[{"property":"display","value":"flex"},{"property":"flex-direction","value":"column"},{"property":"align-items","value":"center"},{"property":"justify-content","value":"center"},{"property":"background-color","value":"rgba(68, 129, 253, 0.08)"},{"property":"width","value":"93px"},{"property":"height","value":"93px"},{"property":"border-top-left-radius","value":"999px"},{"property":"border-top-right-radius","value":"999px"},{"property":"border-bottom-left-radius","value":"999px"},{"property":"border-bottom-right-radius","value":"999px"}]}}],"initialStyles":{}},{"key":"ImageBase __sw-l9fnrzdl9fxcphwivhk1b","value":"","skipInnerHTML":true,"tagName":"img","subType":"img","properties":[{"prefix":"default","property":{"type":"src","src":"https://static.superwallassets.com/oea3YAyfYJa04Wop0Ausp","srcSet":[]}},{"prefix":"default","property":{"type":"styles","styles":[{"property":"width","value":"48px"},{"property":"height","value":"48px"}]}}],"initialStyles":{"width":"100%","height":"auto"}},{"key":"Text __sw-p_5ehkodjsaw5szfwjhay","value":"Limited<br>3 Scripts","skipInnerHTML":false,"tagName":"p","subType":"var","properties":[{"prefix":"default","property":{"type":"styles","styles":[{"property":"font-size","value":"9px"},{"property":"line-height","value":"140%"},{"property":"margin-top","value":"5px"}]}}],"initialStyles":{}},{"key":"Div __sw-wzf7vt0x5qwm_8suk2gxo","value":"","skipInnerHTML":true,"tagName":"div","subType":"var","properties":[{"prefix":"default","property":{"type":"styles","styles":[{"property":"display","value":"flex"},{"property":"flex-direction","value":"column"},{"property":"gap","value":"12px"},{"property":"text-align","value":"left"}]}}],"initialStyles":{}},{"key":"Div __sw-efvuhb7yxirm-nqwnkhuq","value":"","skipInnerHTML":true,"tagName":"div","subType":"var","properties":[{"prefix":"default","property":{"type":"styles","styles":[{"property":"display","value":"flex"},{"property":"align-items","value":"start"},{"property":"justify-content","value":"flex-start"},{"property":"gap","value":"4px"}]}}],"initialStyles":{}},{"key":"ImageBase __sw-c3zje9rkoej-k9ed3keyu","value":"","skipInnerHTML":true,"tagName":"img","subType":"img","properties":[{"prefix":"default","property":{"type":"src","src":"https://static.superwallassets.com/rSPb2Eq9RSGWBwSl-749m","srcSet":[]}},{"prefix":"default","property":{"type":"styles","styles":[{"property":"width","value":"12px"},{"property":"height","value":"12px"},{"property":"margin-top","value":"2px"}]}}],"initialStyles":{"width":"100%","height":"auto"}},{"key":"Text __sw-iuz7ahnwujumdpg5dqnoy","value":"Teleprompter Web & Mobile","skipInnerHTML":false,"tagName":"p","subType":"var","properties":[{"prefix":"default","property":{"type":"styles","styles":[{"property":"font-size","value":"12px"},{"property":"letter-spacing","value":"-0.5px"},{"property":"line-height","value":"140%"}]}}],"initialStyles":{}},{"key":"Div __sw-u0e-dqkkm4i6xwn_v1_aw","value":"","skipInnerHTML":true,"tagName":"div","subType":"var","properties":[{"prefix":"default","property":{"type":"styles","styles":[{"property":"display","value":"flex"},{"property":"align-items","value":"start"},{"property":"justify-content","value":"flex-start"},{"property":"gap","value":"4px"}]}}],"initialStyles":{}},{"key":"ImageBase __sw-isk31vd6ao34kzlba6a4b","value":"","skipInnerHTML":true,"tagName":"img","subType":"img","properties":[{"prefix":"default","property":{"type":"src","src":"https://static.superwallassets.com/rSPb2Eq9RSGWBwSl-749m","srcSet":[]}},{"prefix":"default","property":{"type":"styles","styles":[{"property":"width","value":"12px"},{"property":"height","value":"12px"},{"property":"margin-top","value":"2px"}]}}],"initialStyles":{"width":"100%","height":"auto"}},{"key":"Text __sw-ukv5y0m2zylattqqkjrfx","value":"WordTrim","skipInnerHTML":false,"tagName":"p","subType":"var","properties":[{"prefix":"default","property":{"type":"styles","styles":[{"property":"font-size","value":"12px"},{"property":"letter-spacing","value":"-0.5px"},{"property":"line-height","value":"140%"}]}}],"initialStyles":{}},{"key":"Div __sw-eqfssucfefzqxs7zpipap","value":"","skipInnerHTML":true,"tagName":"div","subType":"var","properties":[{"prefix":"default","property":{"type":"styles","styles":[{"property":"display","value":"flex"},{"property":"align-items","value":"start"},{"property":"justify-content","value":"flex-start"},{"property":"gap","value":"4px"}]}}],"initialStyles":{}},{"key":"ImageBase __sw-elwjhutvg5iyiqdwc4vzb","value":"","skipInnerHTML":true,"tagName":"img","subType":"img","properties":[{"prefix":"default","property":{"type":"src","src":"https://static.superwallassets.com/rSPb2Eq9RSGWBwSl-749m","srcSet":[]}},{"prefix":"default","property":{"type":"styles","styles":[{"property":"width","value":"12px"},{"property":"height","value":"12px"},{"property":"margin-top","value":"2px"}]}}],"initialStyles":{"width":"100%","height":"auto"}},{"key":"Text __sw-hzy8tnplwcjqt10yupkdy","value":"Share on<br>Social","skipInnerHTML":false,"tagName":"p","subType":"var","properties":[{"prefix":"default","property":{"type":"styles","styles":[{"property":"font-size","value":"12px"},{"property":"letter-spacing","value":"-0.5px"},{"property":"line-height","value":"140%"}]}}],"initialStyles":{}},{"key":"Div __sw-kvm6_hxb-zo8l_z_cllr8","value":"","skipInnerHTML":true,"tagName":"div","subType":"var","properties":[{"prefix":"default","property":{"type":"styles","styles":[{"property":"display","value":"flex"},{"property":"align-items","value":"start"},{"property":"justify-content","value":"flex-start"},{"property":"gap","value":"4px"}]}}],"initialStyles":{}},{"key":"ImageBase __sw-a0w99pzskf2ytrfbxwwqq","value":"","skipInnerHTML":true,"tagName":"img","subType":"img","properties":[{"prefix":"default","property":{"type":"src","src":"https://static.superwallassets.com/rSPb2Eq9RSGWBwSl-749m","srcSet":[]}},{"prefix":"default","property":{"type":"styles","styles":[{"property":"width","value":"12px"},{"property":"height","value":"12px"},{"property":"margin-top","value":"2px"}]}}],"initialStyles":{"width":"100%","height":"auto"}},{"key":"Text __sw-fls8uito7o5lpinqoatui","value":"My Video<br>Page","skipInnerHTML":false,"tagName":"p","subType":"var","properties":[{"prefix":"default","property":{"type":"styles","styles":[{"property":"font-size","value":"12px"},{"property":"letter-spacing","value":"-0.5px"},{"property":"line-height","value":"140%"}]}}],"initialStyles":{}},{"key":"Div __sw-aemuueeg3xsrqh_ovegdt","value":"","skipInnerHTML":true,"tagName":"div","subType":"var","properties":[{"prefix":"default","property":{"type":"styles","styles":[{"property":"display","value":"flex"},{"property":"align-items","value":"start"},{"property":"justify-content","value":"flex-start"},{"property":"gap","value":"4px"}]}}],"initialStyles":{}},{"key":"ImageBase __sw-i0uxzt-h50vzz46-4uce0","value":"","skipInnerHTML":true,"tagName":"img","subType":"img","properties":[{"prefix":"default","property":{"type":"src","src":"https://static.superwallassets.com/ut1Ks9EWe-fCS7MbxxaMe","srcSet":[]}},{"prefix":"default","property":{"type":"styles","styles":[{"property":"width","value":"12px"},{"property":"height","value":"12px"},{"property":"margin-top","value":"2px"}]}}],"initialStyles":{"width":"100%","height":"auto"}},{"key":"Text __sw-ym90zluncy3vwyvit0k1j","value":"Video<br>Analytics<br>Dashboard","skipInnerHTML":false,"tagName":"p","subType":"var","properties":[{"prefix":"default","property":{"type":"styles","styles":[{"property":"font-size","value":"12px"},{"property":"letter-spacing","value":"-0.5px"},{"property":"line-height","value":"140%"}]}}],"initialStyles":{}},{"key":"Div __sw-lxcbuddgkx2u4taiowmxv","value":"","skipInnerHTML":true,"tagName":"div","subType":"var","properties":[{"prefix":"default","property":{"type":"styles","styles":[{"property":"text-align","value":"center"},{"property":"background-color","value":"rgba(255, 255, 255, 1)"},{"property":"width","value":"100%"},{"property":"padding-top","value":"16px"},{"property":"padding-bottom","value":"23px"},{"property":"padding-left","value":"8px"},{"property":"padding-right","value":"8px"},{"property":"border-top-left-radius","value":"20px"},{"property":"border-top-right-radius","value":"20px"},{"property":"border-bottom-left-radius","value":"20px"},{"property":"border-bottom-right-radius","value":"20px"}]}}],"initialStyles":{}},{"key":"Text __sw-wg4b09pbmawsorvtbwner","value":"AI Pro","skipInnerHTML":false,"tagName":"p","subType":"var","properties":[{"prefix":"default","property":{"type":"styles","styles":[{"property":"font-size","value":"12px"},{"property":"color","value":"hsl(320, 67%, 57%)"},{"property":"font-weight","value":"700"},{"property":"line-height","value":"15px"},{"property":"background-color","value":"rgba(255, 77, 91, 0.08)"},{"property":"margin-bottom","value":"2px"},{"property":"padding-top","value":"4px"},{"property":"padding-bottom","value":"4px"},{"property":"padding-left","value":"10px"},{"property":"padding-right","value":"10px"},{"property":"border-top-left-radius","value":"20px"},{"property":"border-top-right-radius","value":"20px"},{"property":"border-bottom-left-radius","value":"20px"},{"property":"border-bottom-right-radius","value":"20px"}]}}],"initialStyles":{}},{"key":"Div __sw-icn1wbocsva57aff3gwwh","value":"","skipInnerHTML":true,"tagName":"div","subType":"var","properties":[{"prefix":"default","property":{"type":"styles","styles":[{"property":"display","value":"flex"},{"property":"flex-direction","value":"column"},{"property":"align-items","value":"center"},{"property":"justify-content","value":"flex-start"},{"property":"gap","value":"8px"},{"property":"margin-bottom","value":"12px"}]}}],"initialStyles":{}},{"key":"Div __sw-obujxbij8f4z-zftbaaj-","value":"","skipInnerHTML":true,"tagName":"div","subType":"var","properties":[{"prefix":"default","property":{"type":"styles","styles":[{"property":"display","value":"flex"},{"property":"flex-direction","value":"column"},{"property":"align-items","value":"center"},{"property":"justify-content","value":"center"},{"property":"background-color","value":"rgba(255, 77, 91, 0.08)"},{"property":"width","value":"93px"},{"property":"height","value":"93px"},{"property":"border-top-left-radius","value":"999px"},{"property":"border-top-right-radius","value":"999px"},{"property":"border-bottom-left-radius","value":"999px"},{"property":"border-bottom-right-radius","value":"999px"}]}}],"initialStyles":{}},{"key":"ImageBase __sw-5nkybghhtphfwueifjxr5","value":"","skipInnerHTML":true,"tagName":"img","subType":"img","properties":[{"prefix":"default","property":{"type":"src","src":"https://static.superwallassets.com/d533qdTpVL9W8Tf6XWqzv","srcSet":[]}},{"prefix":"default","property":{"type":"styles","styles":[{"property":"width","value":"64px"},{"property":"height","value":"64px"}]}}],"initialStyles":{"width":"100%","height":"auto"}},{"key":"Text __sw-exjric2dmyqqwmol3hrgr","value":"Watermark","skipInnerHTML":false,"tagName":"p","subType":"var","properties":[{"prefix":"default","property":{"type":"styles","styles":[{"property":"font-size","value":"9px"},{"property":"line-height","value":"120%"},{"property":"margin-top","value":"5px"}]}}],"initialStyles":{}},{"key":"Div __sw-vmneyrubjmreafksxhe2h","value":"","skipInnerHTML":true,"tagName":"div","subType":"var","properties":[{"prefix":"default","property":{"type":"styles","styles":[{"property":"display","value":"flex"},{"property":"flex-direction","value":"column"},{"property":"align-items","value":"center"},{"property":"justify-content","value":"center"},{"property":"background-color","value":"rgba(170, 88, 238, 0.08)"},{"property":"width","value":"93px"},{"property":"height","value":"93px"},{"property":"border-top-left-radius","value":"999px"},{"property":"border-top-right-radius","value":"999px"},{"property":"border-bottom-left-radius","value":"999px"},{"property":"border-bottom-right-radius","value":"999px"}]}}],"initialStyles":{}},{"key":"ImageBase __sw-oatsu64nftexaltasnmnk","value":"","skipInnerHTML":true,"tagName":"img","subType":"img","properties":[{"prefix":"default","property":{"type":"src","src":"https://static.superwallassets.com/mzM24ZEULUc8RcZ8oqE0Z","srcSet":[]}},{"prefix":"default","property":{"type":"styles","styles":[{"property":"width","value":"48px"},{"property":"height","value":"48px"}]}}],"initialStyles":{"width":"100%","height":"auto"},"revision":1705517445706},{"key":"Text __sw-jbka0nrphfpnek66rhyrt","value":"max length<br>per video","skipInnerHTML":false,"tagName":"p","subType":"var","properties":[{"prefix":"default","property":{"type":"styles","styles":[{"property":"font-size","value":"9px"},{"property":"line-height","value":"120%"},{"property":"margin-top","value":"5px"}]}}],"initialStyles":{}},{"key":"Div __sw-0nufusddj_zzzvwfm26jl","value":"","skipInnerHTML":true,"tagName":"div","subType":"var","properties":[{"prefix":"default","property":{"type":"styles","styles":[{"property":"display","value":"flex"},{"property":"flex-direction","value":"column"},{"property":"align-items","value":"center"},{"property":"justify-content","value":"center"},{"property":"background-color","value":"rgba(68, 129, 253, 0.08)"},{"property":"width","value":"93px"},{"property":"height","value":"93px"},{"property":"border-top-left-radius","value":"999px"},{"property":"border-top-right-radius","value":"999px"},{"property":"border-bottom-left-radius","value":"999px"},{"property":"border-bottom-right-radius","value":"999px"}]}}],"initialStyles":{}},{"key":"ImageBase __sw-jmy7kge9zmp9kw02lp3g-","value":"","skipInnerHTML":true,"tagName":"img","subType":"img","properties":[{"prefix":"default","property":{"type":"styles","styles":[{"property":"width","value":"48px"},{"property":"height","value":"48px"}]}},{"prefix":"default","property":{"type":"src","src":"https://static.superwallassets.com/jLfkrG7yS_UZELC45PoGw","srcSet":[]}}],"initialStyles":{"width":"100%","height":"auto"}},{"key":"Text __sw-cjyly4y00kpiufhy2r-wz","value":"Unlimited","skipInnerHTML":false,"tagName":"p","subType":"var","properties":[{"prefix":"default","property":{"type":"styles","styles":[{"property":"font-size","value":"9px"},{"property":"line-height","value":"140%"},{"property":"margin-top","value":"5px"}]}}],"initialStyles":{}},{"key":"Div __sw-ma7pbnzxrpnyg3xnbwib-","value":"","skipInnerHTML":true,"tagName":"div","subType":"var","properties":[{"prefix":"default","property":{"type":"styles","styles":[{"property":"display","value":"flex"},{"property":"flex-direction","value":"column"},{"property":"gap","value":"12px"},{"property":"text-align","value":"left"}]}}],"initialStyles":{}},{"key":"Div __sw-ud5powibhab4l7ahxbgil","value":"","skipInnerHTML":true,"tagName":"div","subType":"var","properties":[{"prefix":"default","property":{"type":"styles","styles":[{"property":"display","value":"flex"},{"property":"align-items","value":"start"},{"property":"justify-content","value":"flex-start"},{"property":"gap","value":"4px"}]}}],"initialStyles":{}},{"key":"ImageBase __sw-splryaq2thmyetlekybf8","value":"","skipInnerHTML":true,"tagName":"img","subType":"img","properties":[{"prefix":"default","property":{"type":"src","src":"https://static.superwallassets.com/ut1Ks9EWe-fCS7MbxxaMe","srcSet":[]}},{"prefix":"default","property":{"type":"styles","styles":[{"property":"width","value":"12px"},{"property":"height","value":"12px"},{"property":"margin-top","value":"2px"}]}}],"initialStyles":{"width":"100%","height":"auto"}},{"key":"Text __sw-xhid3lytdlertuw7tp0yd","value":"All Features in Starter","skipInnerHTML":false,"tagName":"p","subType":"var","properties":[{"prefix":"default","property":{"type":"styles","styles":[{"property":"font-size","value":"12px"},{"property":"letter-spacing","value":"-0.5px"},{"property":"line-height","value":"140%"},{"property":"font-weight","value":"700"}]}}],"initialStyles":{}},{"key":"Div __sw-4ipq2rk0osqvdgla__ykz","value":"","skipInnerHTML":true,"tagName":"div","subType":"var","properties":[{"prefix":"default","property":{"type":"styles","styles":[{"property":"display","value":"flex"},{"property":"align-items","value":"start"},{"property":"justify-content","value":"flex-start"},{"property":"gap","value":"4px"}]}}],"initialStyles":{}},{"key":"ImageBase __sw-zwpqwxa60xp2-6nggujwm","value":"","skipInnerHTML":true,"tagName":"img","subType":"img","properties":[{"prefix":"default","property":{"type":"src","src":"https://static.superwallassets.com/ut1Ks9EWe-fCS7MbxxaMe","srcSet":[]}},{"prefix":"default","property":{"type":"styles","styles":[{"property":"width","value":"12px"},{"property":"height","value":"12px"},{"property":"margin-top","value":"2px"}]}}],"initialStyles":{"width":"100%","height":"auto"}},{"key":"Text __sw--gmxn9ma44kiuzo5wxqqa","value":"59 min video\nmax length","skipInnerHTML":false,"tagName":"p","subType":"var","properties":[{"prefix":"default","property":{"type":"styles","styles":[{"property":"font-size","value":"12px"},{"property":"letter-spacing","value":"-0.5px"},{"property":"line-height","value":"140%"}]}}],"initialStyles":{}},{"key":"Div __sw-tjlj3acv_u6v-kswz1ett","value":"","skipInnerHTML":true,"tagName":"div","subType":"var","properties":[{"prefix":"default","property":{"type":"styles","styles":[{"property":"display","value":"flex"},{"property":"align-items","value":"start"},{"property":"justify-content","value":"flex-start"},{"property":"gap","value":"4px"}]}}],"initialStyles":{}},{"key":"ImageBase __sw-bq4awiqajansk6smbx3ik","value":"","skipInnerHTML":true,"tagName":"img","subType":"img","properties":[{"prefix":"default","property":{"type":"src","src":"https://static.superwallassets.com/ut1Ks9EWe-fCS7MbxxaMe","srcSet":[]}},{"prefix":"default","property":{"type":"styles","styles":[{"property":"width","value":"12px"},{"property":"height","value":"12px"},{"property":"margin-top","value":"2px"}]}}],"initialStyles":{"width":"100%","height":"auto"}},{"key":"Text __sw-0xjad4gkkyeks6qoofbwc","value":"No watermark","skipInnerHTML":false,"tagName":"p","subType":"var","properties":[{"prefix":"default","property":{"type":"styles","styles":[{"property":"font-size","value":"12px"},{"property":"letter-spacing","value":"-0.5px"},{"property":"line-height","value":"140%"}]}}],"initialStyles":{}},{"key":"Div __sw-vgdw5aavkeioc7kor4yie","value":"","skipInnerHTML":true,"tagName":"div","subType":"var","properties":[{"prefix":"default","property":{"type":"styles","styles":[{"property":"display","value":"flex"},{"property":"align-items","value":"start"},{"property":"justify-content","value":"flex-start"},{"property":"gap","value":"4px"}]}}],"initialStyles":{}},{"key":"ImageBase __sw-vc9bmeutuas1ofikp9vyl","value":"","skipInnerHTML":true,"tagName":"img","subType":"img","properties":[{"prefix":"default","property":{"type":"src","src":"https://static.superwallassets.com/ut1Ks9EWe-fCS7MbxxaMe","srcSet":[]}},{"prefix":"default","property":{"type":"styles","styles":[{"property":"width","value":"12px"},{"property":"height","value":"12px"},{"property":"margin-top","value":"2px"}]}}],"initialStyles":{"width":"100%","height":"auto"}},{"key":"Text __sw-xw-ikwarcah6kxva_3bjr","value":"Video<br>Analytics<br>Dashboard","skipInnerHTML":false,"tagName":"p","subType":"var","properties":[{"prefix":"default","property":{"type":"styles","styles":[{"property":"font-size","value":"12px"},{"property":"letter-spacing","value":"-0.5px"},{"property":"line-height","value":"140%"}]}}],"initialStyles":{}},{"key":"Div __sw-ipbfgix2lz1cuyuphnzxz","value":"","skipInnerHTML":true,"tagName":"div","subType":"var","properties":[{"prefix":"default","property":{"type":"styles","styles":[{"property":"display","value":"flex"},{"property":"align-items","value":"start"},{"property":"justify-content","value":"flex-start"},{"property":"gap","value":"4px"}]}}],"initialStyles":{}},{"key":"ImageBase __sw-ok2qo6wiavv5fnsangwyw","value":"","skipInnerHTML":true,"tagName":"img","subType":"img","properties":[{"prefix":"default","property":{"type":"src","src":"https://static.superwallassets.com/ut1Ks9EWe-fCS7MbxxaMe","srcSet":[]}},{"prefix":"default","property":{"type":"styles","styles":[{"property":"width","value":"12px"},{"property":"height","value":"12px"},{"property":"margin-top","value":"2px"}]}}],"initialStyles":{"width":"100%","height":"auto"}},{"key":"Text __sw-fccijr4owiqezsliux3x3","value":"Shared Workspaces","skipInnerHTML":false,"tagName":"p","subType":"var","properties":[{"prefix":"default","property":{"type":"styles","styles":[{"property":"font-size","value":"12px"},{"property":"letter-spacing","value":"-0.5px"},{"property":"line-height","value":"140%"}]}}],"initialStyles":{}},{"key":"Div __sw-ocfdfzcxmzucrgxtr-ox2","value":"","skipInnerHTML":true,"tagName":"div","subType":"var","properties":[{"prefix":"default","property":{"type":"styles","styles":[{"property":"text-align","value":"center"},{"property":"background-color","value":"hsl(216, 100%, 95%)"},{"property":"width","value":"100%"},{"property":"padding-top","value":"16px"},{"property":"padding-bottom","value":"23px"},{"property":"padding-left","value":"8px"},{"property":"padding-right","value":"8px"},{"property":"border-top-left-radius","value":"20px"},{"property":"border-top-right-radius","value":"20px"},{"property":"border-bottom-left-radius","value":"20px"},{"property":"border-bottom-right-radius","value":"20px"}]}}],"initialStyles":{}},{"key":"Text __sw-a4y9knujop9rfhgza6ti5","value":"Starter","skipInnerHTML":false,"tagName":"p","subType":"var","properties":[{"prefix":"default","property":{"type":"styles","styles":[{"property":"font-size","value":"12px"},{"property":"color","value":"hsl(200, 100%, 50%)"},{"property":"font-weight","value":"700"},{"property":"line-height","value":"15px"},{"property":"background-color","value":"rgba(255, 255, 255, 1)"},{"property":"margin-bottom","value":"2px"},{"property":"padding-top","value":"4px"},{"property":"padding-bottom","value":"4px"},{"property":"padding-left","value":"10px"},{"property":"padding-right","value":"10px"},{"property":"border-top-left-radius","value":"20px"},{"property":"border-top-right-radius","value":"20px"},{"property":"border-bottom-left-radius","value":"20px"},{"property":"border-bottom-right-radius","value":"20px"}]}}],"initialStyles":{}},{"key":"Div __sw-edz4ixlpzen_4qvlqb2hx","value":"","skipInnerHTML":true,"tagName":"div","subType":"var","properties":[{"prefix":"default","property":{"type":"styles","styles":[{"property":"display","value":"flex"},{"property":"flex-direction","value":"column"},{"property":"align-items","value":"center"},{"property":"justify-content","value":"flex-start"},{"property":"gap","value":"8px"},{"property":"margin-bottom","value":"12px"}]}}],"initialStyles":{}},{"key":"Div __sw-tliukbusd7t0epusk296u","value":"","skipInnerHTML":true,"tagName":"div","subType":"var","properties":[{"prefix":"default","property":{"type":"styles","styles":[{"property":"display","value":"flex"},{"property":"flex-direction","value":"column"},{"property":"align-items","value":"center"},{"property":"justify-content","value":"center"},{"property":"background-color","value":"#FFFFFF"},{"property":"width","value":"93px"},{"property":"height","value":"93px"},{"property":"border-top-left-radius","value":"999px"},{"property":"border-top-right-radius","value":"999px"},{"property":"border-bottom-left-radius","value":"999px"},{"property":"border-bottom-right-radius","value":"999px"}]}}],"initialStyles":{}},{"key":"ImageBase __sw-xvpmln5mhgnr2koyyphzd","value":"","skipInnerHTML":true,"tagName":"img","subType":"img","properties":[{"prefix":"default","property":{"type":"src","src":"https://static.superwallassets.com/mZAhiKE3pdp7evLuk2wa8","srcSet":[]}},{"prefix":"default","property":{"type":"styles","styles":[{"property":"width","value":"58px"},{"property":"height","value":"50px"}]}}],"initialStyles":{"width":"100%","height":"auto"},"revision":1705517442925},{"key":"Text __sw-d6xv9rzzwjl2n_iszwpxf","value":"Elegant <br>\nsubtitles","skipInnerHTML":false,"tagName":"p","subType":"var","properties":[{"prefix":"default","property":{"type":"styles","styles":[{"property":"font-size","value":"9px"},{"property":"line-height","value":"120%"},{"property":"margin-top","value":"5px"}]}}],"initialStyles":{}},{"key":"Div __sw-eundxgzj-m_cvchb1nlaa","value":"","skipInnerHTML":true,"tagName":"div","subType":"var","properties":[{"prefix":"default","property":{"type":"styles","styles":[{"property":"display","value":"flex"},{"property":"flex-direction","value":"column"},{"property":"align-items","value":"center"},{"property":"justify-content","value":"center"},{"property":"background-color","value":"#FFFFFF"},{"property":"width","value":"93px"},{"property":"height","value":"93px"},{"property":"border-top-left-radius","value":"999px"},{"property":"border-top-right-radius","value":"999px"},{"property":"border-bottom-left-radius","value":"999px"},{"property":"border-bottom-right-radius","value":"999px"}]}}],"initialStyles":{}},{"key":"ImageBase __sw-tlvdax8rca6oqzwhznnh7","value":"","skipInnerHTML":true,"tagName":"img","subType":"img","properties":[{"prefix":"default","property":{"type":"src","src":"https://static.superwallassets.com/Qx1wuxwanlG92i0DuAbaZ","srcSet":[]}},{"prefix":"default","property":{"type":"styles","styles":[{"property":"width","value":"48px"},{"property":"height","value":"48px"}]}}],"initialStyles":{"width":"100%","height":"auto"}},{"key":"Text __sw--wc-jvv8fu4s08vwsbtxy","value":"max length<br>per video","skipInnerHTML":false,"tagName":"p","subType":"var","properties":[{"prefix":"default","property":{"type":"styles","styles":[{"property":"font-size","value":"9px"},{"property":"line-height","value":"120%"},{"property":"margin-top","value":"5px"}]}}],"initialStyles":{}},{"key":"Div __sw-rjt0_xd6ianjl4bxfxdfx","value":"","skipInnerHTML":true,"tagName":"div","subType":"var","properties":[{"prefix":"default","property":{"type":"styles","styles":[{"property":"display","value":"flex"},{"property":"flex-direction","value":"column"},{"property":"align-items","value":"center"},{"property":"justify-content","value":"center"},{"property":"background-color","value":"#FFFFFF"},{"property":"width","value":"93px"},{"property":"height","value":"93px"},{"property":"border-top-left-radius","value":"999px"},{"property":"border-top-right-radius","value":"999px"},{"property":"border-bottom-left-radius","value":"999px"},{"property":"border-bottom-right-radius","value":"999px"}]}}],"initialStyles":{}},{"key":"ImageBase __sw-knz9y9rlxj0lpozjbstff","value":"","skipInnerHTML":true,"tagName":"img","subType":"img","properties":[{"prefix":"default","property":{"type":"styles","styles":[{"property":"width","value":"48px"},{"property":"height","value":"48px"}]}},{"prefix":"default","property":{"type":"src","src":"https://static.superwallassets.com/lbmKB4flMlfP0OVqoosVc","srcSet":[]}}],"initialStyles":{"width":"100%","height":"auto"}},{"key":"Text __sw-w4np6f_ikm1nbciqo5eh5","value":"Limited <br>10 Scripts per month","skipInnerHTML":false,"tagName":"p","subType":"var","properties":[{"prefix":"default","property":{"type":"styles","styles":[{"property":"font-size","value":"9px"},{"property":"line-height","value":"140%"},{"property":"margin-top","value":"5px"}]}}],"initialStyles":{}},{"key":"Div __sw-x3rmy77lmn1ajdnw4sbm2","value":"","skipInnerHTML":true,"tagName":"div","subType":"var","properties":[{"prefix":"default","property":{"type":"styles","styles":[{"property":"display","value":"flex"},{"property":"flex-direction","value":"column"},{"property":"gap","value":"12px"},{"property":"text-align","value":"left"}]}}],"initialStyles":{}},{"key":"Div __sw-u_7m0da3p_x9mig9fgxk_","value":"","skipInnerHTML":true,"tagName":"div","subType":"var","properties":[{"prefix":"default","property":{"type":"styles","styles":[{"property":"display","value":"flex"},{"property":"align-items","value":"start"},{"property":"justify-content","value":"flex-start"},{"property":"gap","value":"4px"}]}}],"initialStyles":{}},{"key":"ImageBase __sw-raotuis6wenraouyujtey","value":"","skipInnerHTML":true,"tagName":"img","subType":"img","properties":[{"prefix":"default","property":{"type":"src","src":"https://static.superwallassets.com/4055G-MNuHlk6yABOKwBB","srcSet":[]}},{"prefix":"default","property":{"type":"styles","styles":[{"property":"width","value":"12px"},{"property":"height","value":"12px"},{"property":"margin-top","value":"2px"}]}}],"initialStyles":{"width":"100%","height":"auto"}},{"key":"Text __sw-qyqgaqyizymcw2u1ehojf","value":"All Features \nin FREE","skipInnerHTML":false,"tagName":"p","subType":"var","properties":[{"prefix":"default","property":{"type":"styles","styles":[{"property":"font-size","value":"12px"},{"property":"font-weight","value":"700"},{"property":"letter-spacing","value":"-0.5px"},{"property":"line-height","value":"140%"}]}}],"initialStyles":{}},{"key":"Div __sw-iq5bzvwt22w5ay3zk5lun","value":"","skipInnerHTML":true,"tagName":"div","subType":"var","properties":[{"prefix":"default","property":{"type":"styles","styles":[{"property":"display","value":"flex"},{"property":"align-items","value":"start"},{"property":"justify-content","value":"flex-start"},{"property":"gap","value":"4px"}]}}],"initialStyles":{},"revision":1695883023239},{"key":"ImageBase __sw-c92kcbvvlpr6mn2skjtxj","value":"","skipInnerHTML":true,"tagName":"img","subType":"img","properties":[{"prefix":"default","property":{"type":"src","src":"https://static.superwallassets.com/4055G-MNuHlk6yABOKwBB","srcSet":[]}},{"prefix":"default","property":{"type":"styles","styles":[{"property":"width","value":"12px"},{"property":"height","value":"12px"},{"property":"margin-top","value":"2px"}]}}],"initialStyles":{"width":"100%","height":"auto"}},{"key":"Text __sw-jiyajth2aqlu8snrinj0m","value":"9 min video\nmax length ","skipInnerHTML":false,"tagName":"p","subType":"var","properties":[{"prefix":"default","property":{"type":"styles","styles":[{"property":"font-size","value":"12px"},{"property":"letter-spacing","value":"-0.5px"},{"property":"line-height","value":"140%"}]}}],"initialStyles":{},"revision":1695883051528},{"key":"Div __sw-1nwabcdsqc-bupw44mhuc","value":"","skipInnerHTML":true,"tagName":"div","subType":"var","properties":[{"prefix":"default","property":{"type":"styles","styles":[{"property":"display","value":"flex"},{"property":"align-items","value":"start"},{"property":"justify-content","value":"flex-start"},{"property":"gap","value":"4px"}]}}],"initialStyles":{}},{"key":"ImageBase __sw-sljkg4ku5va25o7_ioc8z","value":"","skipInnerHTML":true,"tagName":"img","subType":"img","properties":[{"prefix":"default","property":{"type":"src","src":"https://static.superwallassets.com/4055G-MNuHlk6yABOKwBB","srcSet":[]}},{"prefix":"default","property":{"type":"styles","styles":[{"property":"width","value":"12px"},{"property":"height","value":"12px"},{"property":"margin-top","value":"2px"}]}}],"initialStyles":{"width":"100%","height":"auto"}},{"key":"Text __sw-cyzrng0ao4jipqffvbhr6","value":"No watermark","skipInnerHTML":false,"tagName":"p","subType":"var","properties":[{"prefix":"default","property":{"type":"styles","styles":[{"property":"font-size","value":"12px"},{"property":"letter-spacing","value":"-0.5px"},{"property":"line-height","value":"140%"}]}}],"initialStyles":{}},{"key":"Div __sw-lq7grntnhuqes7ydq_e8f","value":"","skipInnerHTML":true,"tagName":"div","subType":"var","properties":[{"prefix":"default","property":{"type":"styles","styles":[{"property":"display","value":"flex"},{"property":"align-items","value":"start"},{"property":"justify-content","value":"flex-start"},{"property":"gap","value":"4px"}]}}],"initialStyles":{}},{"key":"ImageBase __sw-d9ealytfwdjrr0gdkt206","value":"","skipInnerHTML":true,"tagName":"img","subType":"img","properties":[{"prefix":"default","property":{"type":"src","src":"https://static.superwallassets.com/4055G-MNuHlk6yABOKwBB","srcSet":[]}},{"prefix":"default","property":{"type":"styles","styles":[{"property":"width","value":"12px"},{"property":"height","value":"12px"},{"property":"margin-top","value":"2px"}]}}],"initialStyles":{"width":"100%","height":"auto"}},{"key":"Text __sw-otjfrw2a6fl7o6ccfy3ex","value":"My Video PageAutomatic Subtitles with Elegant Themes\nYour Logo, Music","skipInnerHTML":false,"tagName":"p","subType":"var","properties":[{"prefix":"default","property":{"type":"styles","styles":[{"property":"font-size","value":"12px"},{"property":"letter-spacing","value":"-0.5px"},{"property":"line-height","value":"140%"}]}}],"initialStyles":{}},{"key":"Div __sw-1jdrxdgkjlgiyprbxjhm0","value":"","skipInnerHTML":true,"tagName":"div","subType":"var","properties":[{"prefix":"default","property":{"type":"styles","styles":[{"property":"display","value":"flex"},{"property":"align-items","value":"start"},{"property":"justify-content","value":"flex-start"},{"property":"gap","value":"4px"}]}}],"initialStyles":{}},{"key":"ImageBase __sw-oa-gt3fmswa-d_vkywmdk","value":"","skipInnerHTML":true,"tagName":"img","subType":"img","properties":[{"prefix":"default","property":{"type":"src","src":"https://static.superwallassets.com/ut1Ks9EWe-fCS7MbxxaMe","srcSet":[]}},{"prefix":"default","property":{"type":"styles","styles":[{"property":"width","value":"12px"},{"property":"height","value":"12px"},{"property":"margin-top","value":"2px"}]}}],"initialStyles":{"width":"100%","height":"auto"}},{"key":"Text __sw-fj9xwjihgz_fm7uskeq7s","value":"Video Analytics\nDashboard","skipInnerHTML":false,"tagName":"p","subType":"var","properties":[{"prefix":"default","property":{"type":"styles","styles":[{"property":"font-size","value":"12px"},{"property":"letter-spacing","value":"-0.5px"},{"property":"line-height","value":"140%"}]}}],"initialStyles":{}},{"key":"Section __sw-lw1h1qmc4nx9-dkkan36b","value":"","skipInnerHTML":true,"tagName":"div","subType":"var","properties":[{"prefix":"default","property":{"type":"styles","styles":[{"property":"padding-bottom","value":"48px"}]}}],"revision":1705518713903},{"key":"Text __sw-ubwlrgdqnbdkmijgt1i66","value":"10 Million Happy Video Makers 🎉","skipInnerHTML":false,"tagName":"p","subType":"var","properties":[{"prefix":"default","property":{"type":"styles","styles":[{"property":"font-size","value":"1rem"},{"property":"font-weight","value":"600"},{"property":"line-height","value":"140%"},{"property":"text-align","value":"center"},{"property":"margin-bottom","value":"16px"}]}}],"initialStyles":{},"revision":1705517315980},{"key":"List __sw-iua2dssu6yzsxjkk8km7b","value":"","skipInnerHTML":true,"tagName":"div","subType":"var","properties":[{"prefix":"default","property":{"type":"styles","styles":[{"property":"display","value":"flex"},{"property":"align-items","value":"stretch"},{"property":"padding-top","value":"0px"},{"property":"padding-bottom","value":"0px"}]}}]},{"key":"List-indicators __sw-iua2dssu6yzsxjkk8km7b","value":"","skipInnerHTML":true,"tagName":"div","subType":"var","properties":[{"prefix":"default","property":{"type":"styles","styles":[{"property":"position","value":"absolute"},{"property":"bottom","value":"0px"},{"property":"display","value":"none"}]}}]},{"key":"Review __sw-auzghqbjhebfsjv3h1_gn","value":"","skipInnerHTML":true,"tagName":"div","subType":"var","properties":[{"prefix":"default","property":{"type":"styles","styles":[{"property":"background-color","value":"rgba(255, 255, 255, 1)"},{"property":"width","value":"80%"}]}}],"revision":1705518713442},{"key":"Review __sw-auzghqbjhebfsjv3h1_gn > Container","value":"","skipInnerHTML":true,"tagName":"div","subType":"var","properties":[]},{"key":"Review __sw-auzghqbjhebfsjv3h1_gn > Header Container","value":"","skipInnerHTML":true,"tagName":"div","subType":"var","properties":[{"prefix":"default","property":{"type":"styles","styles":[{"property":"display","value":"flex"},{"property":"flex-direction","value":"column-reverse"}]}}]},{"key":"Review __sw-auzghqbjhebfsjv3h1_gn > Title Container","value":"","skipInnerHTML":true,"tagName":"div","subType":"var","properties":[{"prefix":"default","property":{"type":"styles","styles":[{"property":"font-size","value":"14px"},{"property":"line-height","value":"110%"}]}}]},{"key":"Review __sw-auzghqbjhebfsjv3h1_gn > Title","value":"BIGVU is Easy.","skipInnerHTML":false,"tagName":"p","subType":"var","properties":[{"prefix":"default","property":{"type":"styles","styles":[{"property":"font-size","value":"14px"},{"property":"margin-top","value":"8px"}]}}]},{"key":"Review __sw-auzghqbjhebfsjv3h1_gn > Date","value":"Dec 15","skipInnerHTML":false,"tagName":"p","subType":"var","properties":[{"prefix":"default","property":{"type":"styles","styles":[{"property":"display","value":"none"}]}}]},{"key":"Review __sw-auzghqbjhebfsjv3h1_gn > Info","value":"","skipInnerHTML":true,"tagName":"div","subType":"var","properties":[]},{"key":"Review __sw-auzghqbjhebfsjv3h1_gn > Star Container","value":"","skipInnerHTML":true,"tagName":"div","subType":"var","properties":[{"prefix":"default","property":{"type":"styles","styles":[{"property":"width","value":"auto"},{"property":"height","value":"16px"}]}}]},{"key":"Review __sw-auzghqbjhebfsjv3h1_gn > Author","value":"Jane Doe","skipInnerHTML":false,"tagName":"p","subType":"var","properties":[{"prefix":"default","property":{"type":"styles","styles":[{"property":"display","value":"none"}]}}]},{"key":"Review __sw-auzghqbjhebfsjv3h1_gn > Body","value":"Making videos is easy, BIGVU saves me so much time.","skipInnerHTML":false,"tagName":"p","subType":"var","properties":[{"prefix":"default","property":{"type":"styles","styles":[{"property":"font-size","value":"12px"},{"property":"line-height","value":"140%"}]}}]},{"key":"Review __sw-3k6ym6_gaa9ioynyz1jbo","value":"","skipInnerHTML":true,"tagName":"div","subType":"var","properties":[{"prefix":"default","property":{"type":"styles","styles":[{"property":"background-color","value":"rgba(255, 255, 255, 1)"},{"property":"width","value":"80%"}]}}]},{"key":"Review __sw-3k6ym6_gaa9ioynyz1jbo > Container","value":"","skipInnerHTML":true,"tagName":"div","subType":"var","properties":[]},{"key":"Review __sw-3k6ym6_gaa9ioynyz1jbo > Header Container","value":"","skipInnerHTML":true,"tagName":"div","subType":"var","properties":[{"prefix":"default","property":{"type":"styles","styles":[{"property":"display","value":"flex"},{"property":"flex-direction","value":"column-reverse"}]}}]},{"key":"Review __sw-3k6ym6_gaa9ioynyz1jbo > Title Container","value":"","skipInnerHTML":true,"tagName":"div","subType":"var","properties":[{"prefix":"default","property":{"type":"styles","styles":[{"property":"font-size","value":"14px"},{"property":"line-height","value":"110%"}]}}]},{"key":"Review __sw-3k6ym6_gaa9ioynyz1jbo > Title","value":"Best app ever.","skipInnerHTML":false,"tagName":"p","subType":"var","properties":[{"prefix":"default","property":{"type":"styles","styles":[{"property":"font-size","value":"14px"},{"property":"margin-top","value":"8px"}]}}]},{"key":"Review __sw-3k6ym6_gaa9ioynyz1jbo > Date","value":"Dec 15","skipInnerHTML":false,"tagName":"p","subType":"var","properties":[{"prefix":"default","property":{"type":"styles","styles":[{"property":"display","value":"none"}]}}]},{"key":"Review __sw-3k6ym6_gaa9ioynyz1jbo > Info","value":"","skipInnerHTML":true,"tagName":"div","subType":"var","properties":[]},{"key":"Review __sw-3k6ym6_gaa9ioynyz1jbo > Star Container","value":"","skipInnerHTML":true,"tagName":"div","subType":"var","properties":[{"prefix":"default","property":{"type":"styles","styles":[{"property":"width","value":"auto"},{"property":"height","value":"16px"}]}}]},{"key":"Review __sw-3k6ym6_gaa9ioynyz1jbo > Author","value":"Jane Doe","skipInnerHTML":false,"tagName":"p","subType":"var","properties":[{"prefix":"default","property":{"type":"styles","styles":[{"property":"display","value":"none"}]}}]},{"key":"Review __sw-3k6ym6_gaa9ioynyz1jbo > Body","value":"The teleprompter feature is a game changer!","skipInnerHTML":false,"tagName":"p","subType":"var","properties":[{"prefix":"default","property":{"type":"styles","styles":[{"property":"font-size","value":"12px"},{"property":"line-height","value":"140%"}]}}]},{"key":"Review __sw-vy8ybw0oyoabza0p3ctfn","value":"","skipInnerHTML":true,"tagName":"div","subType":"var","properties":[{"prefix":"default","property":{"type":"styles","styles":[{"property":"background-color","value":"rgba(255, 255, 255, 1)"},{"property":"width","value":"80%"}]}}]},{"key":"Review __sw-vy8ybw0oyoabza0p3ctfn > Container","value":"","skipInnerHTML":true,"tagName":"div","subType":"var","properties":[]},{"key":"Review __sw-vy8ybw0oyoabza0p3ctfn > Header Container","value":"","skipInnerHTML":true,"tagName":"div","subType":"var","properties":[{"prefix":"default","property":{"type":"styles","styles":[{"property":"display","value":"flex"},{"property":"flex-direction","value":"column-reverse"}]}}]},{"key":"Review __sw-vy8ybw0oyoabza0p3ctfn > Title Container","value":"","skipInnerHTML":true,"tagName":"div","subType":"var","properties":[{"prefix":"default","property":{"type":"styles","styles":[{"property":"font-size","value":"14px"},{"property":"line-height","value":"110%"}]}}]},{"key":"Review __sw-vy8ybw0oyoabza0p3ctfn > Title","value":"Fantastic","skipInnerHTML":false,"tagName":"p","subType":"var","properties":[{"prefix":"default","property":{"type":"styles","styles":[{"property":"margin-top","value":"8px"}]}}]},{"key":"Review __sw-vy8ybw0oyoabza0p3ctfn > Date","value":"Dec 15","skipInnerHTML":false,"tagName":"p","subType":"var","properties":[{"prefix":"default","property":{"type":"styles","styles":[{"property":"display","value":"none"}]}}]},{"key":"Review __sw-vy8ybw0oyoabza0p3ctfn > Info","value":"","skipInnerHTML":true,"tagName":"div","subType":"var","properties":[]},{"key":"Review __sw-vy8ybw0oyoabza0p3ctfn > Star Container","value":"","skipInnerHTML":true,"tagName":"div","subType":"var","properties":[{"prefix":"default","property":{"type":"styles","styles":[{"property":"width","value":"auto"},{"property":"height","value":"16px"}]}}]},{"key":"Review __sw-vy8ybw0oyoabza0p3ctfn > Author","value":"Jane Doe","skipInnerHTML":false,"tagName":"p","subType":"var","properties":[{"prefix":"default","property":{"type":"styles","styles":[{"property":"display","value":"none"}]}}]},{"key":"Review __sw-vy8ybw0oyoabza0p3ctfn > Body","value":"I create polished videos to impress my audience.","skipInnerHTML":false,"tagName":"p","subType":"var","properties":[{"prefix":"default","property":{"type":"styles","styles":[{"property":"font-size","value":"12px"},{"property":"line-height","value":"140%"}]}}]},{"key":"Review __sw-o3nqksc-y2bikyyxzfoxw","value":"","skipInnerHTML":true,"tagName":"div","subType":"var","properties":[{"prefix":"default","property":{"type":"styles","styles":[{"property":"background-color","value":"rgba(255, 255, 255, 1)"},{"property":"width","value":"80%"}]}}]},{"key":"Review __sw-o3nqksc-y2bikyyxzfoxw > Container","value":"","skipInnerHTML":true,"tagName":"div","subType":"var","properties":[]},{"key":"Review __sw-o3nqksc-y2bikyyxzfoxw > Header Container","value":"","skipInnerHTML":true,"tagName":"div","subType":"var","properties":[{"prefix":"default","property":{"type":"styles","styles":[{"property":"display","value":"flex"},{"property":"flex-direction","value":"column-reverse"}]}}]},{"key":"Review __sw-o3nqksc-y2bikyyxzfoxw > Title Container","value":"","skipInnerHTML":true,"tagName":"div","subType":"var","properties":[{"prefix":"default","property":{"type":"styles","styles":[{"property":"font-size","value":"14px"},{"property":"line-height","value":"110%"}]}}]},{"key":"Review __sw-o3nqksc-y2bikyyxzfoxw > Title","value":"I love BIGVU","skipInnerHTML":false,"tagName":"p","subType":"var","properties":[{"prefix":"default","property":{"type":"styles","styles":[{"property":"margin-top","value":"8px"}]}}]},{"key":"Review __sw-o3nqksc-y2bikyyxzfoxw > Date","value":"Dec 15","skipInnerHTML":false,"tagName":"p","subType":"var","properties":[{"prefix":"default","property":{"type":"styles","styles":[{"property":"display","value":"none"}]}}]},{"key":"Review __sw-o3nqksc-y2bikyyxzfoxw > Info","value":"","skipInnerHTML":true,"tagName":"div","subType":"var","properties":[]},{"key":"Review __sw-o3nqksc-y2bikyyxzfoxw > Star Container","value":"","skipInnerHTML":true,"tagName":"div","subType":"var","properties":[{"prefix":"default","property":{"type":"styles","styles":[{"property":"width","value":"auto"},{"property":"height","value":"16px"}]}}]},{"key":"Review __sw-o3nqksc-y2bikyyxzfoxw > Author","value":"Jane Doe","skipInnerHTML":false,"tagName":"p","subType":"var","properties":[{"prefix":"default","property":{"type":"styles","styles":[{"property":"display","value":"none"}]}}]},{"key":"Review __sw-o3nqksc-y2bikyyxzfoxw > Body","value":"Video production simplified, making it accessible for anyone to use.","skipInnerHTML":false,"tagName":"p","subType":"var","properties":[{"prefix":"default","property":{"type":"styles","styles":[{"property":"font-size","value":"12px"},{"property":"line-height","value":"140%"}]}}]},{"key":"Section __sw-0wihk5qzvyeuduehcn1g_","value":"","skipInnerHTML":true,"tagName":"div","subType":"var","properties":[{"prefix":"default","property":{"type":"styles","styles":[{"property":"padding-bottom","value":"48px"},{"property":"padding-left","value":"16px"},{"property":"padding-right","value":"16px"}]}}],"revision":1705518711961},{"key":"Text __sw-woh9qkd6a_knfjob3zyf3","value":"Need help? Get a free coaching session","skipInnerHTML":false,"tagName":"p","subType":"var","properties":[{"prefix":"default","property":{"type":"styles","styles":[{"property":"font-size","value":"1rem"},{"property":"font-weight","value":"600"},{"property":"line-height","value":"140%"},{"property":"text-align","value":"center"},{"property":"margin-bottom","value":"16px"}]}}],"initialStyles":{},"revision":1705517609967},{"key":"Div __sw-j3ojjyj0xr7j8hfe57lsb","value":"","skipInnerHTML":true,"tagName":"div","subType":"var","properties":[{"prefix":"default","property":{"type":"styles","styles":[{"property":"text-align","value":"center"},{"property":"background-color","value":"rgba(255, 255, 255, 1)"},{"property":"padding-top","value":"12px"},{"property":"padding-bottom","value":"12px"},{"property":"padding-left","value":"12px"},{"property":"padding-right","value":"12px"},{"property":"border-top-left-radius","value":"20px"},{"property":"border-top-right-radius","value":"20px"},{"property":"border-bottom-left-radius","value":"20px"},{"property":"border-bottom-right-radius","value":"20px"},{"property":"box-shadow","value":"0px 0px 40px rgba(0, 0, 0, 0.1)"}]}}],"initialStyles":{}},{"key":"ImageBase __sw-x_hbomikqvhpays9ygx9x","value":"","skipInnerHTML":true,"tagName":"img","subType":"img","properties":[{"prefix":"default","property":{"type":"src","src":"https://static.superwallassets.com/XkTPBQJWwCqMh998eDqSi","srcSet":[]}},{"prefix":"default","property":{"type":"styles","styles":[{"property":"width","value":"80px"},{"property":"height","value":"80px"},{"property":"margin-bottom","value":"8px"}]}}],"initialStyles":{"width":"100%","height":"auto"}},{"key":"Text __sw-gvtmgqvhou8ngrvjj0_t8","value":"&nbsp;","skipInnerHTML":false,"tagName":"p","subType":"var","properties":[{"prefix":"default","property":{"type":"styles","styles":[{"property":"font-size","value":"10px"},{"property":"line-height","value":"140%"},{"property":"margin-bottom","value":"8px"}]}}],"initialStyles":{}},{"key":"Text __sw-ramu2xp_kr5ifs5n5gj-e","value":"3-day trial","skipInnerHTML":false,"tagName":"p","subType":"var","properties":[{"prefix":"default","property":{"type":"styles","styles":[{"property":"font-size","value":"10px"},{"property":"line-height","value":"140%"},{"property":"margin-bottom","value":"8px"}]}}],"initialStyles":{}},{"key":"Text __sw-durnh87ka4h7oecv9rj-f","value":"3-day trial","skipInnerHTML":false,"tagName":"p","subType":"var","properties":[{"prefix":"default","property":{"type":"styles","styles":[{"property":"font-size","value":"10px"},{"property":"line-height","value":"140%"},{"property":"margin-bottom","value":"8px"}]}}],"initialStyles":{},"revision":1701420889845},{"key":"Text __sw-c_csynkf6e-5f1l2dbf-z","value":"Sarah Stanfield","skipInnerHTML":false,"tagName":"p","subType":"var","properties":[{"prefix":"default","property":{"type":"styles","styles":[{"property":"font-size","value":"1rem"},{"property":"line-height","value":"140%"},{"property":"font-weight","value":"600"},{"property":"margin-bottom","value":"4px"}]}}],"initialStyles":{}},{"key":"Text __sw-6ht8jwykpxoizzx9r5zae","value":"BIGVU Expert","skipInnerHTML":false,"tagName":"p","subType":"var","properties":[{"prefix":"default","property":{"type":"styles","styles":[{"property":"font-size","value":"14px"},{"property":"line-height","value":"20px"},{"property":"margin-bottom","value":"16px"}]}}],"initialStyles":{}},{"key":"ButtonBase __sw-atzjs7wzo3s1lef6bzkp_","value":"Schedule a zoom call","skipInnerHTML":false,"tagName":"button","subType":"var","properties":[{"prefix":"default","property":{"type":"click-behavior","clickBehavior":{"type":"open-url-external","url":"https://calendly.com/bigvu-success-team"}}},{"prefix":"default","property":{"type":"styles","styles":[{"property":"font-size","value":"1rem"},{"property":"line-height","value":"140%"},{"property":"background-color","value":"#00ABFE"},{"property":"width","value":"100%"},{"property":"height","value":"44px"}]}}]},{"key":"Section __sw-csw4b0gwk_sw3svfl6oi8","value":"","skipInnerHTML":true,"tagName":"div","subType":"var","properties":[{"prefix":"default","property":{"type":"styles","styles":[{"property":"padding-top","value":"20px"},{"property":"padding-bottom","value":"48px"},{"property":"padding-left","value":"16px"},{"property":"padding-right","value":"16px"}]}}],"revision":1705518718653},{"key":"Text __sw-tvertplbbscssl0wt3ftw","value":"How Your Free Trial Works","skipInnerHTML":false,"tagName":"p","subType":"var","properties":[{"prefix":"default","property":{"type":"styles","styles":[{"property":"font-size","value":"1rem"},{"property":"font-weight","value":"600"},{"property":"line-height","value":"140%"},{"property":"text-align","value":"center"},{"property":"margin-bottom","value":"16px"}]}}],"initialStyles":{}},{"key":"Div __sw-55giv9tcntvxdd94-6xhk","value":"","skipInnerHTML":true,"tagName":"div","subType":"var","properties":[{"prefix":"default","property":{"type":"styles","styles":[{"property":"text-align","value":"center"},{"property":"background-color","value":"rgba(255, 255, 255, 1)"},{"property":"padding-top","value":"16px"},{"property":"padding-bottom","value":"16px"},{"property":"padding-left","value":"16px"},{"property":"padding-right","value":"16px"},{"property":"border-top-left-radius","value":"20px"},{"property":"border-top-right-radius","value":"20px"},{"property":"border-bottom-left-radius","value":"20px"},{"property":"border-bottom-right-radius","value":"20px"},{"property":"box-shadow","value":"0px 0px 40px rgba(0, 0, 0, 0.1)"}]}}],"initialStyles":{},"revision":1705518718127},{"key":"ImageBase __sw-lrd2kklroeurs3oo9japc","value":"","skipInnerHTML":true,"tagName":"img","subType":"img","properties":[{"prefix":"default","property":{"type":"src","src":"https://static.superwallassets.com/XkTPBQJWwCqMh998eDqSi","srcSet":[]}},{"prefix":"default","property":{"type":"styles","styles":[{"property":"width","value":"80px"},{"property":"height","value":"80px"},{"property":"margin-bottom","value":"8px"}]}}],"initialStyles":{"width":"100%","height":"auto"}},{"key":"Text __sw-toygp2yvwpedkmz6-uo5s","value":"Sarah Stanfield","skipInnerHTML":false,"tagName":"p","subType":"var","properties":[{"prefix":"default","property":{"type":"styles","styles":[{"property":"font-size","value":"1rem"},{"property":"line-height","value":"140%"},{"property":"font-weight","value":"600"},{"property":"margin-bottom","value":"4px"}]}}],"initialStyles":{}},{"key":"Text __sw-zms17twar_th6rnrpnxgr","value":"BIGVU Expert","skipInnerHTML":false,"tagName":"p","subType":"var","properties":[{"prefix":"default","property":{"type":"styles","styles":[{"property":"font-size","value":"14px"},{"property":"line-height","value":"20px"},{"property":"margin-bottom","value":"16px"}]}}],"initialStyles":{}},{"key":"ButtonBase __sw-cpwdqbwnarirbfug3hv_r","value":"Schedule a zoom call","skipInnerHTML":false,"tagName":"button","subType":"var","properties":[{"prefix":"default","property":{"type":"styles","styles":[{"property":"font-size","value":"1rem"},{"property":"line-height","value":"140%"},{"property":"background-color","value":"#00ABFE"},{"property":"height","value":"44px"},{"property":"width","value":"100%"}]}}]},{"key":"Timeline __sw-bt0b6klxzoqsilewsk-bb","value":"","skipInnerHTML":true,"tagName":"div","subType":"var","properties":[],"revision":1705517231571},{"key":"Timeline __sw-bt0b6klxzoqsilewsk-bb > Timelin-item __sw--axddtle8vy_cmatbv1cg","value":"","skipInnerHTML":true,"tagName":"div","subType":"var","properties":[]},{"key":"Timeline __sw-bt0b6klxzoqsilewsk-bb > Timelin-item __sw--axddtle8vy_cmatbv1cg > Icon Container","value":"","skipInnerHTML":true,"tagName":"div","subType":"img","properties":[{"prefix":"default","property":{"type":"src","src":"../public/assets/t-check.svg","srcSet":[""]}},{"prefix":"default","property":{"type":"styles","styles":[{"property":"background-color","value":"rgba(255, 255, 255, 1)"},{"property":"box-shadow","value":"0px 0px 40px rgba(0, 0, 0, 0.1)"}]}}]},{"key":"Timeline __sw-bt0b6klxzoqsilewsk-bb > Timelin-item __sw--axddtle8vy_cmatbv1cg > Icon Wrapper","value":"","skipInnerHTML":true,"tagName":"div","subType":"img","properties":[{"prefix":"default","property":{"type":"src","src":"../public/assets/t-check.svg","srcSet":[""]}}]},{"key":"Timeline __sw-bt0b6klxzoqsilewsk-bb > Timelin-item __sw--axddtle8vy_cmatbv1cg > Icon","value":"","skipInnerHTML":true,"tagName":"img","subType":"img","properties":[{"prefix":"default","property":{"type":"src","src":"https://static.superwallassets.com/Zmvi_IxJR9CXLj0Wkw1MA","srcSet":[]}}]},{"key":"Timeline __sw-bt0b6klxzoqsilewsk-bb > Timelin-item __sw--axddtle8vy_cmatbv1cg > Trail Line","value":"","skipInnerHTML":false,"tagName":"div","subType":"var","properties":[{"prefix":"default","property":{"type":"styles","styles":[{"property":"width","value":"2px"},{"property":"background-color","value":"rgba(68, 129, 253, 0.30)"}]}}],"revision":1705517254890},{"key":"Timeline __sw-bt0b6klxzoqsilewsk-bb > Timelin-item __sw--axddtle8vy_cmatbv1cg > Content","value":"","skipInnerHTML":true,"tagName":"div","subType":"var","properties":[]},{"key":"Timeline __sw-bt0b6klxzoqsilewsk-bb > Timelin-item __sw--axddtle8vy_cmatbv1cg > Row Title","value":"Today","skipInnerHTML":false,"tagName":"h3","subType":"var","properties":[]},{"key":"Timeline __sw-bt0b6klxzoqsilewsk-bb > Timelin-item __sw--axddtle8vy_cmatbv1cg > Body Text","value":"Unlock full access to your \npremium subscription","skipInnerHTML":false,"tagName":"p","subType":"var","properties":[{"prefix":"default","property":{"type":"styles","styles":[{"property":"margin-top","value":"8px"}]}}],"revision":1705517205547},{"key":"Timeline __sw-bt0b6klxzoqsilewsk-bb > Timelin-item __sw-zsvvozbwfaxzitvufqky9","value":"","skipInnerHTML":true,"tagName":"div","subType":"var","properties":[]},{"key":"Timeline __sw-bt0b6klxzoqsilewsk-bb > Timelin-item __sw-zsvvozbwfaxzitvufqky9 > Icon Container","value":"","skipInnerHTML":true,"tagName":"div","subType":"img","properties":[{"prefix":"default","property":{"type":"src","src":"../public/assets/t-check.svg","srcSet":[""]}},{"prefix":"default","property":{"type":"styles","styles":[{"property":"box-shadow","value":"0px 0px 40px rgba(0, 0, 0, 0.1)"},{"property":"background-color","value":"rgba(255, 255, 255, 1)"}]}}]},{"key":"Timeline __sw-bt0b6klxzoqsilewsk-bb > Timelin-item __sw-zsvvozbwfaxzitvufqky9 > Icon Wrapper","value":"","skipInnerHTML":true,"tagName":"div","subType":"img","properties":[{"prefix":"default","property":{"type":"src","src":"../public/assets/t-check.svg","srcSet":[""]}}]},{"key":"Timeline __sw-bt0b6klxzoqsilewsk-bb > Timelin-item __sw-zsvvozbwfaxzitvufqky9 > Icon","value":"","skipInnerHTML":true,"tagName":"img","subType":"img","properties":[{"prefix":"default","property":{"type":"src","src":"https://static.superwallassets.com/jszOlhB6hWGGdFroZ1Jrh","srcSet":[]}}]},{"key":"Timeline __sw-bt0b6klxzoqsilewsk-bb > Timelin-item __sw-zsvvozbwfaxzitvufqky9 > Trail Line","value":"","skipInnerHTML":false,"tagName":"div","subType":"var","properties":[{"prefix":"default","property":{"type":"styles","styles":[{"property":"width","value":"2px"},{"property":"background-color","value":"rgba(68, 129, 253, 0.30)"}]}}],"revision":1705517258714},{"key":"Timeline __sw-bt0b6klxzoqsilewsk-bb > Timelin-item __sw-zsvvozbwfaxzitvufqky9 > Content","value":"","skipInnerHTML":true,"tagName":"div","subType":"var","properties":[]},{"key":"Timeline __sw-bt0b6klxzoqsilewsk-bb > Timelin-item __sw-zsvvozbwfaxzitvufqky9 > Row Title","value":"The Day Before Trial Ends","skipInnerHTML":false,"tagName":"h3","subType":"var","properties":[]},{"key":"Timeline __sw-bt0b6klxzoqsilewsk-bb > Timelin-item __sw-zsvvozbwfaxzitvufqky9 > Body Text","value":"Get reminded when your trial \nis about to end","skipInnerHTML":false,"tagName":"p","subType":"var","properties":[{"prefix":"default","property":{"type":"styles","styles":[{"property":"margin-top","value":"8px"}]}}],"revision":1705517207474},{"key":"Timeline __sw-bt0b6klxzoqsilewsk-bb > Timelin-item __sw-3qwsfyiirkn_sjx2fk63w","value":"","skipInnerHTML":true,"tagName":"div","subType":"var","properties":[],"revision":1705517224919},{"key":"Timeline __sw-bt0b6klxzoqsilewsk-bb > Timelin-item __sw-3qwsfyiirkn_sjx2fk63w > Icon Container","value":"","skipInnerHTML":true,"tagName":"div","subType":"img","properties":[{"prefix":"default","property":{"type":"src","src":"../public/assets/t-check.svg","srcSet":[""]}},{"prefix":"default","property":{"type":"styles","styles":[{"property":"background-color","value":"rgba(255, 255, 255, 1)"},{"property":"box-shadow","value":"0px 0px 40px rgba(0, 0, 0, 0.1)"}]}}],"revision":1705517165548},{"key":"Timeline __sw-bt0b6klxzoqsilewsk-bb > Timelin-item __sw-3qwsfyiirkn_sjx2fk63w > Icon Wrapper","value":"","skipInnerHTML":true,"tagName":"div","subType":"img","properties":[{"prefix":"default","property":{"type":"src","src":"../public/assets/t-check.svg","srcSet":[""]}}]},{"key":"Timeline __sw-bt0b6klxzoqsilewsk-bb > Timelin-item __sw-3qwsfyiirkn_sjx2fk63w > Icon","value":"","skipInnerHTML":true,"tagName":"img","subType":"img","properties":[{"prefix":"default","property":{"type":"src","src":"https://static.superwallassets.com/_2Pc0HS_JPlhSgSRwWpU4","srcSet":[]}}],"revision":1705517164676},{"key":"Timeline __sw-bt0b6klxzoqsilewsk-bb > Timelin-item __sw-3qwsfyiirkn_sjx2fk63w > Trail Line","value":"","skipInnerHTML":false,"tagName":"div","subType":"var","properties":[{"prefix":"default","property":{"type":"styles","styles":[{"property":"width","value":"2px"},{"property":"display","value":"none"}]}}],"revision":1705517234686},{"key":"Timeline __sw-bt0b6klxzoqsilewsk-bb > Timelin-item __sw-3qwsfyiirkn_sjx2fk63w > Content","value":"","skipInnerHTML":true,"tagName":"div","subType":"var","properties":[]},{"key":"Timeline __sw-bt0b6klxzoqsilewsk-bb > Timelin-item __sw-3qwsfyiirkn_sjx2fk63w > Row Title","value":"Trial Ends","skipInnerHTML":false,"tagName":"h3","subType":"var","properties":[]},{"key":"Timeline __sw-bt0b6klxzoqsilewsk-bb > Timelin-item __sw-3qwsfyiirkn_sjx2fk63w > Body Text","value":"Your account is charged, cancel anytime 24 hours before.","skipInnerHTML":false,"tagName":"p","subType":"var","properties":[{"prefix":"default","property":{"type":"styles","styles":[{"property":"margin-top","value":"8px"}]}}],"revision":1705517209880},{"key":"Text __sw-zp7cgy3o6xg8vgg6wtbnt","value":"Already Subscribed","skipInnerHTML":false,"tagName":"p","subType":"var","properties":[{"prefix":"default","property":{"type":"click-behavior","clickBehavior":{"type":"restore"}}},{"prefix":"default","property":{"type":"styles","styles":[{"property":"font-size","value":"14px"},{"property":"line-height","value":"140%"},{"property":"text-align","value":"center"},{"property":"margin-top","value":"16px"}]}}],"initialStyles":{},"revision":1705517495143},{"key":"Div __sw-zpjldarejzcn-9mgugwbj","value":"","skipInnerHTML":true,"tagName":"div","subType":"var","properties":[{"prefix":"default","property":{"type":"styles","styles":[{"property":"padding-bottom","value":"24px"}]}}],"initialStyles":{},"revision":1705517567262},{"key":"Div __sw-d8tccrofqtwxbahel2nyv","value":"","skipInnerHTML":true,"tagName":"div","subType":"var","properties":[{"prefix":"default","property":{"type":"styles","styles":[{"property":"background-color","value":"rgba(255, 255, 255, 1)"},{"property":"position","value":"fixed"},{"property":"bottom","value":"0px"},{"property":"left","value":"0%"},{"property":"right","value":"0%"},{"property":"z-index","value":"100"},{"property":"width","value":"100%"},{"property":"max-width","value":"468px"},{"property":"margin-left","value":"auto"},{"property":"margin-right","value":"auto"},{"property":"padding-top","value":"16px"},{"property":"padding-bottom","value":"34px"},{"property":"padding-left","value":"16px"},{"property":"padding-right","value":"16px"},{"property":"border-top-left-radius","value":"24px"},{"property":"border-top-right-radius","value":"24px"},{"property":"box-shadow","value":"0px 0px 40px rgba(0, 0, 0, 0.1)"}]}}],"initialStyles":{},"revision":1705517509585},{"key":"Text __sw-irmzdfvpfcvbr4qo2iox7","value":"AI PRO 6-month","skipInnerHTML":false,"tagName":"p","subType":"var","properties":[{"prefix":"default","property":{"type":"styles","styles":[{"property":"font-size","value":"1rem"},{"property":"color","value":"rgba(37, 54, 88, 1)"},{"property":"font-weight","value":"600"},{"property":"line-height","value":"140%"},{"property":"text-align","value":"center"},{"property":"margin-bottom","value":"8px"}]}}],"initialStyles":{}},{"key":"Text __sw-wpxt0nyddoq9barby-j23","value":"Free 3-day trial, {{primary.price}} after trial ends","skipInnerHTML":false,"tagName":"p","subType":"var","properties":[{"prefix":"default","property":{"type":"styles","styles":[{"property":"font-size","value":"13px"},{"property":"color","value":"rgba(37, 54, 88, 1)"},{"property":"font-weight","value":"400"},{"property":"line-height","value":"140%"},{"property":"text-align","value":"center"},{"property":"margin-bottom","value":"16px"}]}}],"initialStyles":{},"revision":1701420898313},{"key":"ButtonBase __sw-ijxd4to28r2rvemzb61kr","value":"Start Your Free 3-Day Trial","skipInnerHTML":false,"tagName":"button","subType":"var","properties":[{"prefix":"default","property":{"type":"click-behavior","clickBehavior":{"type":"purchase","product":"primary"}}},{"prefix":"default","property":{"type":"styles","styles":[{"property":"line-height","value":"48px"},{"property":"background-color","value":"rgba(0, 208, 150, 1)"},{"property":"opacity","value":"1"},{"property":"width","value":"100%"},{"property":"height","value":"48px"},{"property":"margin-bottom","value":"16px"},{"property":"padding-top","value":"10px"},{"property":"padding-bottom","value":"10px"},{"property":"padding-left","value":"10px"},{"property":"padding-right","value":"10px"},{"property":"border-top-left-radius","value":"10px"},{"property":"border-top-right-radius","value":"10px"},{"property":"border-bottom-left-radius","value":"10px"},{"property":"border-bottom-right-radius","value":"10px"}]}}],"revision":1701420943723},{"key":"Text __sw-spi99f-jex79olctcdtld","value":"See All Plans","skipInnerHTML":false,"tagName":"p","subType":"var","properties":[{"prefix":"default","property":{"type":"styles","styles":[{"property":"font-size","value":"1rem"},{"property":"color","value":"rgba(68, 129, 253, 1)"},{"property":"font-weight","value":"600"},{"property":"line-height","value":"140%"},{"property":"text-align","value":"center"},{"property":"display","value":"none"}]}}],"initialStyles":{}},{"key":"Heading __sw-ta6pjckg5ghycjngra4nk","value":"<div class=\"main-heading\">\n\nGet more attention<br>\nwith <span class=\"accent-heading\">Captions</span>\n\n</div>","skipInnerHTML":false,"tagName":"h1","subType":"var","properties":[{"prefix":"default","property":{"type":"styles","styles":[{"property":"padding-left","value":"24px"},{"property":"padding-right","value":"24px"},{"property":"text-align","value":"left"}]}}],"initialStyles":{},"revision":1705518702252},{"key":"Div __sw-5g9wt12cjabkl30vfuhdq","value":"","skipInnerHTML":true,"tagName":"div","subType":"var","properties":[{"prefix":"default","property":{"type":"styles","styles":[{"property":"display","value":"flex"},{"property":"flex-direction","value":"row"},{"property":"align-items","value":"center"},{"property":"justify-content","value":"center"},{"property":"gap","value":"12px"},{"property":"margin-top","value":"calc(var(--sw-container-padding)/2)"},{"property":"padding-top","value":"calc(var(--sw-container-padding) * 0.6)"},{"property":"padding-bottom","value":"calc(var(--sw-container-padding) * 0.6)"}]}}],"revision":1705517496753},{"key":"Text __sw-0h7lr61cybzwg78kcimso","value":"Details","skipInnerHTML":false,"tagName":"p","subType":"var","properties":[{"prefix":"default","property":{"type":"styles","styles":[{"property":"font-size","value":"14px"},{"property":"line-height","value":"140%"},{"property":"padding-left","value":"calc(var(--sw-font-size) * 0.125)"},{"property":"padding-right","value":"calc(var(--sw-font-size) * 0.125)"}]}}],"revision":1705517393376},{"key":"Text __sw-3k9se29ecmpfi86xezisp","value":"•","skipInnerHTML":false,"tagName":"p","subType":"var","properties":[{"prefix":"default","property":{"type":"styles","styles":[{"property":"font-size","value":"14px"},{"property":"line-height","value":"140%"},{"property":"padding-left","value":"calc(var(--sw-font-size) * 0.125)"},{"property":"padding-right","value":"calc(var(--sw-font-size) * 0.125)"}]}}],"revision":1705517396322},{"key":"Text __sw-ccigjvtjd9ekxmr7ifet1","value":"Terms","skipInnerHTML":false,"tagName":"p","subType":"var","properties":[{"prefix":"default","property":{"type":"click-behavior","clickBehavior":{"type":"open-url-external","url":"https://bigvu.tv/terms"}}},{"prefix":"default","property":{"type":"styles","styles":[{"property":"display","value":"inline-block"},{"property":"padding-top","value":"0"},{"property":"padding-bottom","value":"0"},{"property":"padding-left","value":"calc(var(--sw-font-size) * 0.125)"},{"property":"padding-right","value":"calc(var(--sw-font-size) * 0.125)"},{"property":"font-size","value":"14px"},{"property":"line-height","value":"140%"}]}}],"revision":1705517328606},{"key":"Text __sw-lrocoetvyoejxp93vnw0k","value":"•","skipInnerHTML":false,"tagName":"p","subType":"var","properties":[{"prefix":"default","property":{"type":"styles","styles":[{"property":"display","value":"inline-block"},{"property":"padding-top","value":"0"},{"property":"padding-bottom","value":"0"},{"property":"padding-left","value":"calc(var(--sw-font-size) * 0.125)"},{"property":"padding-right","value":"calc(var(--sw-font-size) * 0.125)"},{"property":"font-size","value":"14px"},{"property":"line-height","value":"140%"}]}}]},{"key":"Text __sw-8jwciwif9e2j8jdwooc07","value":"Privacy","skipInnerHTML":false,"tagName":"p","subType":"var","properties":[{"prefix":"default","property":{"type":"click-behavior","clickBehavior":{"type":"open-url-external","url":"https://bigvu.tv/pt/privacy-policy"}}},{"prefix":"default","property":{"type":"styles","styles":[{"property":"display","value":"inline-block"},{"property":"padding-top","value":"0"},{"property":"padding-bottom","value":"0"},{"property":"padding-left","value":"calc(var(--sw-font-size) * 0.125)"},{"property":"padding-right","value":"calc(var(--sw-font-size) * 0.125)"},{"property":"font-size","value":"14px"},{"property":"line-height","value":"140%"}]}}]},{"key":"Divider __sw-4j4nq29ecmpfl23xezyo9","value":"","skipInnerHTML":true,"tagName":"div","subType":"var","properties":[{"prefix":"default","property":{"type":"styles","styles":[{"property":"margin-bottom","value":"calc(var(--sw-container-padding)/2)"}]}}]},{"key":"Products __sw-fxodjntkhoqjxmh7inqf5","value":"","skipInnerHTML":true,"tagName":"div","subType":"var","properties":[],"revision":1705517579047},{"key":"Drawer __sw-0e8je29ecmpfi86xeztrw","value":"","skipInnerHTML":true,"tagName":"div","subType":"var","properties":[{"prefix":"default","property":{"type":"styles","styles":[{"property":"background-color","value":"rgba(255, 255, 255, 1)"},{"property":"max-width","value":"440px"},{"property":"margin-bottom","value":"0px"},{"property":"padding-bottom","value":"34px"},{"property":"padding-left","value":"16px"},{"property":"padding-right","value":"16px"},{"property":"border-top-left-radius","value":"24px"},{"property":"border-top-right-radius","value":"24px"},{"property":"border-bottom-left-radius","value":"0px"},{"property":"border-bottom-right-radius","value":"0px"},{"property":"padding-top","value":"16px"},{"property":"color","value":"#FF86BC"},{"property":"font-weight","value":"600"},{"property":"line-height","value":"140%"}]}}],"revision":1705518096496},{"key":"Products __sw-fxodjntkhoqjxmh7inqf5 > Products Options Close Button Container","value":"","skipInnerHTML":true,"tagName":"div","subType":"var","properties":[{"prefix":"default","property":{"type":"styles","styles":[{"property":"background-color","value":"rgba(255, 255, 255, 1)"}]}}]},{"key":"Div __sw-7s3ke84fvlroq44xeawhn","value":"","skipInnerHTML":true,"tagName":"div","subType":"var","properties":[]},{"key":"Div __sw-0e8je29ecmpfi30dezboi","value":"","skipInnerHTML":true,"tagName":"div","subType":"var","properties":[]},{"key":"Products __sw-fxodjntkhoqjxmh7inqf5 > Products Section Inner Container","value":"","skipInnerHTML":true,"tagName":"div","subType":"var","properties":[]},{"key":"Products __sw-fxodjntkhoqjxmh7inqf5 > Product Options","value":"","skipInnerHTML":true,"tagName":"div","subType":"var","properties":[]},{"key":"Products __sw-fxodjntkhoqjxmh7inqf5 > Product","value":"","skipInnerHTML":true,"tagName":"div","subType":"var","properties":[]},{"key":"Products __sw-fxodjntkhoqjxmh7inqf5 > Product Bg","value":".","skipInnerHTML":false,"tagName":"div","subType":"var","properties":[]},{"key":"Products __sw-fxodjntkhoqjxmh7inqf5 > Product Bg 2","value":".","skipInnerHTML":false,"tagName":"div","subType":"var","properties":[]},{"key":"Products __sw-fxodjntkhoqjxmh7inqf5 > Product Badge","value":"","skipInnerHTML":true,"tagName":"div","subType":"var","properties":[]},{"key":"Products __sw-fxodjntkhoqjxmh7inqf5 > Product Badge Inner","value":"Free Trial","skipInnerHTML":false,"tagName":"span","subType":"var","properties":[]},{"key":"Products __sw-fxodjntkhoqjxmh7inqf5 > Product Inner Container","value":"","skipInnerHTML":true,"tagName":"div","subType":"var","properties":[]},{"key":"Products __sw-fxodjntkhoqjxmh7inqf5 > Check Mark Container","value":"","skipInnerHTML":true,"tagName":"div","subType":"var","properties":[]},{"key":"Products __sw-fxodjntkhoqjxmh7inqf5 > Product Content Container","value":"","skipInnerHTML":true,"tagName":"div","subType":"var","properties":[]},{"key":"Products __sw-fxodjntkhoqjxmh7inqf5 > Primary Line 1","value":"$0.99","skipInnerHTML":false,"tagName":"p","subType":"var","properties":[]},{"key":"Products __sw-fxodjntkhoqjxmh7inqf5 > Primary Line 2","value":"Line 2","skipInnerHTML":false,"tagName":"p","subType":"var","properties":[]},{"key":"Products __sw-fxodjntkhoqjxmh7inqf5 > Product Content Container 2","value":"","skipInnerHTML":true,"tagName":"div","subType":"var","properties":[]},{"key":"Products __sw-fxodjntkhoqjxmh7inqf5 > Primary Line 3","value":"Line 3","skipInnerHTML":false,"tagName":"p","subType":"var","properties":[]},{"key":"Products __sw-fxodjntkhoqjxmh7inqf5 > Primary Line 4","value":"Line 4","skipInnerHTML":false,"tagName":"p","subType":"var","properties":[]},{"key":"Products __sw-fxodjntkhoqjxmh7inqf5 > Product 2","value":"","skipInnerHTML":true,"tagName":"div","subType":"var","properties":[]},{"key":"Products __sw-fxodjntkhoqjxmh7inqf5 > Product Bg 3","value":".","skipInnerHTML":false,"tagName":"div","subType":"var","properties":[]},{"key":"Products __sw-fxodjntkhoqjxmh7inqf5 > Product Bg 4","value":".","skipInnerHTML":false,"tagName":"div","subType":"var","properties":[]},{"key":"Products __sw-fxodjntkhoqjxmh7inqf5 > Product Badge 2","value":"","skipInnerHTML":true,"tagName":"div","subType":"var","properties":[]},{"key":"Products __sw-fxodjntkhoqjxmh7inqf5 > Product Badge Inner 2","value":"Free Trial","skipInnerHTML":false,"tagName":"span","subType":"var","properties":[]},{"key":"Products __sw-fxodjntkhoqjxmh7inqf5 > Product Inner Container 2","value":"","skipInnerHTML":true,"tagName":"div","subType":"var","properties":[]},{"key":"Products __sw-fxodjntkhoqjxmh7inqf5 > Check Mark Container 2","value":"","skipInnerHTML":true,"tagName":"div","subType":"var","properties":[]},{"key":"Products __sw-fxodjntkhoqjxmh7inqf5 > Product Content Container 3","value":"","skipInnerHTML":true,"tagName":"div","subType":"var","properties":[]},{"key":"Products __sw-fxodjntkhoqjxmh7inqf5 > Secondary Line 1","value":"$0.99","skipInnerHTML":false,"tagName":"p","subType":"var","properties":[]},{"key":"Products __sw-fxodjntkhoqjxmh7inqf5 > Secondary Line 2","value":"Line 2","skipInnerHTML":false,"tagName":"p","subType":"var","properties":[]},{"key":"Products __sw-fxodjntkhoqjxmh7inqf5 > Product Content Container 4","value":"","skipInnerHTML":true,"tagName":"div","subType":"var","properties":[]},{"key":"Products __sw-fxodjntkhoqjxmh7inqf5 > Secondary Line 3","value":"Line 3","skipInnerHTML":false,"tagName":"p","subType":"var","properties":[]},{"key":"Products __sw-fxodjntkhoqjxmh7inqf5 > Secondary Line 4","value":"Line 4","skipInnerHTML":false,"tagName":"p","subType":"var","properties":[]},{"key":"Products __sw-fxodjntkhoqjxmh7inqf5 > Product 3","value":"","skipInnerHTML":true,"tagName":"div","subType":"var","properties":[]},{"key":"Products __sw-fxodjntkhoqjxmh7inqf5 > Product Bg 5","value":".","skipInnerHTML":false,"tagName":"div","subType":"var","properties":[]},{"key":"Products __sw-fxodjntkhoqjxmh7inqf5 > Product Bg 6","value":".","skipInnerHTML":false,"tagName":"div","subType":"var","properties":[]},{"key":"Products __sw-fxodjntkhoqjxmh7inqf5 > Product Badge 3","value":"","skipInnerHTML":true,"tagName":"div","subType":"var","properties":[]},{"key":"Products __sw-fxodjntkhoqjxmh7inqf5 > Product Badge Inner 3","value":"Free Trial","skipInnerHTML":false,"tagName":"span","subType":"var","properties":[]},{"key":"Products __sw-fxodjntkhoqjxmh7inqf5 > Product Inner Container 3","value":"","skipInnerHTML":true,"tagName":"div","subType":"var","properties":[]},{"key":"Products __sw-fxodjntkhoqjxmh7inqf5 > Check Mark Container 3","value":"","skipInnerHTML":true,"tagName":"div","subType":"var","properties":[]},{"key":"Products __sw-fxodjntkhoqjxmh7inqf5 > Product Content Container 5","value":"","skipInnerHTML":true,"tagName":"div","subType":"var","properties":[]},{"key":"Products __sw-fxodjntkhoqjxmh7inqf5 > Tertiary Line 1","value":"$0.99","skipInnerHTML":false,"tagName":"p","subType":"var","properties":[]},{"key":"Products __sw-fxodjntkhoqjxmh7inqf5 > Tertiary Line 2","value":"Line 2","skipInnerHTML":false,"tagName":"p","subType":"var","properties":[]},{"key":"Products __sw-fxodjntkhoqjxmh7inqf5 > Product Content Container 6","value":"","skipInnerHTML":true,"tagName":"div","subType":"var","properties":[]},{"key":"Products __sw-fxodjntkhoqjxmh7inqf5 > Tertiary Line 3","value":"Line 3","skipInnerHTML":false,"tagName":"p","subType":"var","properties":[]},{"key":"Products __sw-fxodjntkhoqjxmh7inqf5 > Tertiary Line 4","value":"Line 4","skipInnerHTML":false,"tagName":"p","subType":"var","properties":[]},{"key":"Products __sw-fxodjntkhoqjxmh7inqf5 > Purchase Button Container","value":"","skipInnerHTML":true,"tagName":"div","subType":"var","properties":[]},{"key":"Products __sw-fxodjntkhoqjxmh7inqf5 > Purchase Line One","value":"Subscribe now","freeTrialValue":"Start Free Trial","skipInnerHTML":false,"tagName":"div","subType":"var","properties":[],"revision":1705518126462},{"key":"Products __sw-fxodjntkhoqjxmh7inqf5 > Purchase Line Two","value":"Line Two","skipInnerHTML":false,"tagName":"div","subType":"var","properties":[{"prefix":"default","property":{"type":"styles","styles":[{"property":"display","value":"none"}]}}]},{"key":"Products __sw-fxodjntkhoqjxmh7inqf5 > Purchase Subtitle","value":"No commitment, cancel anytime.","freeTrialValue":"{{ primary.trialPeriodDays }}-day free trial, then {{ primary.price }} after trial ends","skipInnerHTML":false,"tagName":"p","subType":"var","properties":[{"prefix":"default","property":{"type":"styles","styles":[{"property":"font-size","value":"12px"},{"property":"font-weight","value":"400"},{"property":"line-height","value":"140%"},{"property":"opacity","value":"1"},{"property":"margin-bottom","value":"0px"}]}}],"revision":1705518283241},{"key":"Products __sw-fxodjntkhoqjxmh7inqf5 > Purchase Button Container 2","value":"","skipInnerHTML":true,"tagName":"div","subType":"var","properties":[]},{"key":"Products __sw-fxodjntkhoqjxmh7inqf5 > Purchase Line One 2","value":"Purchase Secondary","skipInnerHTML":false,"tagName":"div","subType":"var","properties":[]},{"key":"Products __sw-fxodjntkhoqjxmh7inqf5 > Purchase Line Two 2","value":"Line Two","skipInnerHTML":false,"tagName":"div","subType":"var","properties":[{"prefix":"default","property":{"type":"styles","styles":[{"property":"display","value":"none"}]}}]},{"key":"Products __sw-fxodjntkhoqjxmh7inqf5 > Purchase Subtitle 2","value":"secondary selected description","skipInnerHTML":false,"tagName":"p","subType":"var","properties":[{"prefix":"default","property":{"type":"styles","styles":[{"property":"margin-bottom","value":"0px"}]}}]},{"key":"Products __sw-fxodjntkhoqjxmh7inqf5 > Purchase Button Container 3","value":"","skipInnerHTML":true,"tagName":"div","subType":"var","properties":[]},{"key":"Products __sw-fxodjntkhoqjxmh7inqf5 > Purchase Line One 3","value":"Purchase Tertiary","skipInnerHTML":false,"tagName":"div","subType":"var","properties":[]},{"key":"Products __sw-fxodjntkhoqjxmh7inqf5 > Purchase Line Two 3","value":"Line Two","skipInnerHTML":false,"tagName":"div","subType":"var","properties":[{"prefix":"default","property":{"type":"styles","styles":[{"property":"display","value":"none"}]}}]},{"key":"Products __sw-fxodjntkhoqjxmh7inqf5 > Purchase Subtitle 3","value":"tertiary selected description","skipInnerHTML":false,"tagName":"p","subType":"var","properties":[{"prefix":"default","property":{"type":"styles","styles":[{"property":"margin-bottom","value":"0px"}]}}]},{"key":"Products __sw-fxodjntkhoqjxmh7inqf5 > Options Button Container","value":"","skipInnerHTML":true,"tagName":"div","subType":"var","properties":[]},{"key":"Products __sw-fxodjntkhoqjxmh7inqf5 > Pointer","value":"","skipInnerHTML":true,"tagName":"div","subType":"var","properties":[],"revision":1705517573429},{"key":"Products __sw-fxodjntkhoqjxmh7inqf5 > Options Button","value":"See All Plans","skipInnerHTML":false,"tagName":"p","subType":"var","properties":[{"prefix":"default","property":{"type":"styles","styles":[{"property":"color","value":"hsla(220, 98%, 63%, 1)"}]}}],"revision":1705517572961},{"key":"Products __sw-fxodjntkhoqjxmh7inqf5 > Hidden","value":"","skipInnerHTML":true,"tagName":"div","subType":"var","properties":[]},{"key":"Products __sw-fxodjntkhoqjxmh7inqf5 > Text","value":"{{primary.price}}","skipInnerHTML":false,"tagName":"p","subType":"var","properties":[]},{"key":"Products __sw-fxodjntkhoqjxmh7inqf5 > Text 2","value":"{{secondary.price}}","skipInnerHTML":false,"tagName":"p","subType":"var","properties":[]},{"key":"Products __sw-fxodjntkhoqjxmh7inqf5 > Text 3","value":"{{tertiary.price}}","skipInnerHTML":false,"tagName":"p","subType":"var","properties":[]},{"key":"Products __sw-fxodjntkhoqjxmh7inqf5 > Container 2","value":"AI PRO 6-month","skipInnerHTML":false,"tagName":"div","subType":"var","properties":[]},{"key":"Products __sw-fxodjntkhoqjxmh7inqf5 > Container 3","value":"Free 3-day trial, $59.99 after trial ends","skipInnerHTML":false,"tagName":"div","subType":"var","properties":[]},{"key":"Products __sw-fxodjntkhoqjxmh7inqf5 > H Divider","value":"","skipInnerHTML":false,"tagName":"div","subType":"var","properties":[]},{"key":"Products __sw-fxodjntkhoqjxmh7inqf5 > H Divider 2","value":"","skipInnerHTML":false,"tagName":"div","subType":"var","properties":[]},{"key":"Products __sw-fxodjntkhoqjxmh7inqf5 > H Divider 3","value":"","skipInnerHTML":false,"tagName":"div","subType":"var","properties":[]},{"key":"restore-1","value":"Terms","skipInnerHTML":false,"tagName":"p","subType":"var","properties":[{"prefix":"default","property":{"type":"click-behavior","clickBehavior":{"type":"restore"}}}]},{"key":"footer","value":"","skipInnerHTML":true,"tagName":"div","subType":"var","properties":[]},{"key":"Footer Minimal First","value":"Terms of Use","skipInnerHTML":false,"tagName":"p","subType":"var","properties":[]},{"key":"Footer Minimal Last","value":"Privacy Policy","skipInnerHTML":false,"tagName":"p","subType":"var","properties":[]},{"key":"Footer First","value":"Details","skipInnerHTML":false,"tagName":"p","subType":"var","properties":[]},{"key":"Footer Last","value":"Privacy","skipInnerHTML":false,"tagName":"p","subType":"var","properties":[]},{"key":"Footer Column 1","value":"Details","skipInnerHTML":false,"tagName":"p","subType":"var","properties":[{"prefix":"default","property":{"type":"styles","styles":[{"property":"font-size","value":"14px"},{"property":"line-height","value":"140%"},{"property":"display","value":"none"}]}}]},{"key":"Footer Column 2","value":"•","skipInnerHTML":false,"tagName":"p","subType":"var","properties":[{"prefix":"default","property":{"type":"styles","styles":[{"property":"font-size","value":"14px"},{"property":"line-height","value":"140%"},{"property":"display","value":"none"}]}}]},{"key":"Footer Column 3","value":"Terms","skipInnerHTML":false,"tagName":"p","subType":"var","properties":[{"prefix":"default","property":{"type":"click-behavior","clickBehavior":{"type":"open-url-external","url":"https://bigvu.tv/terms"}}},{"prefix":"default","property":{"type":"styles","styles":[{"property":"font-size","value":"14px"},{"property":"line-height","value":"140%"}]}}]},{"key":"Footer Column 4","value":"•","skipInnerHTML":false,"tagName":"p","subType":"var","properties":[{"prefix":"default","property":{"type":"styles","styles":[{"property":"font-size","value":"14px"},{"property":"line-height","value":"140%"}]}}]},{"key":"Footer Column 5","value":"Privacy","skipInnerHTML":false,"tagName":"p","subType":"var","properties":[{"prefix":"default","property":{"type":"click-behavior","clickBehavior":{"type":"open-url-external","url":"https://bigvu.tv/pt/privacy-policy"}}},{"prefix":"default","property":{"type":"styles","styles":[{"property":"font-size","value":"14px"},{"property":"line-height","value":"140%"}]}}]},{"key":"Purchase Drawer","value":"","skipInnerHTML":true,"tagName":"div","subType":"var","properties":[{"prefix":"default","property":{"type":"styles","styles":[{"property":"background-color","value":"rgba(255, 255, 255, 1)"},{"property":"max-width","value":"440px"},{"property":"margin-bottom","value":"0px"},{"property":"padding-bottom","value":"34px"},{"property":"border-top-left-radius","value":"24px"},{"property":"border-top-right-radius","value":"24px"},{"property":"border-bottom-left-radius","value":"0px"},{"property":"border-bottom-right-radius","value":"0px"},{"property":"display","value":"none"}]}}]},{"key":"Purchase Drawer > Products Options Close Button Container","value":"","skipInnerHTML":true,"tagName":"div","subType":"var","properties":[{"prefix":"default","property":{"type":"styles","styles":[{"property":"background-color","value":"rgba(255, 255, 255, 1)"}]}}]},{"key":"Purchase Drawer > Card Content Container","value":"","skipInnerHTML":true,"tagName":"div","subType":"var","properties":[]},{"key":"Purchase Drawer > Container","value":"","skipInnerHTML":true,"tagName":"div","subType":"var","properties":[]},{"key":"Purchase Drawer > Drawer Inner Container","value":"","skipInnerHTML":true,"tagName":"div","subType":"var","properties":[]},{"key":"Purchase Drawer > Product Options","value":"","skipInnerHTML":true,"tagName":"div","subType":"var","properties":[]},{"key":"Purchase Drawer > Product","value":"","skipInnerHTML":true,"tagName":"div","subType":"var","properties":[]},{"key":"Purchase Drawer > Product Bg","value":".","skipInnerHTML":false,"tagName":"div","subType":"var","properties":[]},{"key":"Purchase Drawer > Product Bg 2","value":".","skipInnerHTML":false,"tagName":"div","subType":"var","properties":[]},{"key":"Purchase Drawer > Product Badge","value":"","skipInnerHTML":true,"tagName":"div","subType":"var","properties":[]},{"key":"Purchase Drawer > Product Badge Inner","value":"Free Trial","skipInnerHTML":false,"tagName":"span","subType":"var","properties":[]},{"key":"Purchase Drawer > Product Inner Container","value":"","skipInnerHTML":true,"tagName":"div","subType":"var","properties":[]},{"key":"Purchase Drawer > Check Mark Container","value":"","skipInnerHTML":true,"tagName":"div","subType":"var","properties":[]},{"key":"Purchase Drawer > Product Content Container","value":"","skipInnerHTML":true,"tagName":"div","subType":"var","properties":[]},{"key":"Purchase Drawer > Primary Line 1","value":"$0.99","skipInnerHTML":false,"tagName":"p","subType":"var","properties":[]},{"key":"Purchase Drawer > Primary Line 2","value":"Line 2","skipInnerHTML":false,"tagName":"p","subType":"var","properties":[]},{"key":"Purchase Drawer > Product Content Container 2","value":"","skipInnerHTML":true,"tagName":"div","subType":"var","properties":[]},{"key":"Purchase Drawer > Primary Line 3","value":"Line 3","skipInnerHTML":false,"tagName":"p","subType":"var","properties":[]},{"key":"Purchase Drawer > Primary Line 4","value":"Line 4","skipInnerHTML":false,"tagName":"p","subType":"var","properties":[]},{"key":"Purchase Drawer > Product 2","value":"","skipInnerHTML":true,"tagName":"div","subType":"var","properties":[]},{"key":"Purchase Drawer > Product Bg 3","value":".","skipInnerHTML":false,"tagName":"div","subType":"var","properties":[]},{"key":"Purchase Drawer > Product Bg 4","value":".","skipInnerHTML":false,"tagName":"div","subType":"var","properties":[]},{"key":"Purchase Drawer > Product Badge 2","value":"","skipInnerHTML":true,"tagName":"div","subType":"var","properties":[]},{"key":"Purchase Drawer > Product Badge Inner 2","value":"Free Trial","skipInnerHTML":false,"tagName":"span","subType":"var","properties":[]},{"key":"Purchase Drawer > Product Inner Container 2","value":"","skipInnerHTML":true,"tagName":"div","subType":"var","properties":[]},{"key":"Purchase Drawer > Check Mark Container 2","value":"","skipInnerHTML":true,"tagName":"div","subType":"var","properties":[]},{"key":"Purchase Drawer > Product Content Container 3","value":"","skipInnerHTML":true,"tagName":"div","subType":"var","properties":[]},{"key":"Purchase Drawer > Secondary Line 1","value":"$0.99","skipInnerHTML":false,"tagName":"p","subType":"var","properties":[]},{"key":"Purchase Drawer > Secondary Line 2","value":"Line 2","skipInnerHTML":false,"tagName":"p","subType":"var","properties":[]},{"key":"Purchase Drawer > Product Content Container 4","value":"","skipInnerHTML":true,"tagName":"div","subType":"var","properties":[]},{"key":"Purchase Drawer > Secondary Line 3","value":"Line 3","skipInnerHTML":false,"tagName":"p","subType":"var","properties":[]},{"key":"Purchase Drawer > Secondary Line 4","value":"Line 4","skipInnerHTML":false,"tagName":"p","subType":"var","properties":[]},{"key":"Purchase Drawer > Product 3","value":"","skipInnerHTML":true,"tagName":"div","subType":"var","properties":[]},{"key":"Purchase Drawer > Product Bg 5","value":".","skipInnerHTML":false,"tagName":"div","subType":"var","properties":[]},{"key":"Purchase Drawer > Product Bg 6","value":".","skipInnerHTML":false,"tagName":"div","subType":"var","properties":[]},{"key":"Purchase Drawer > Product Badge 3","value":"","skipInnerHTML":true,"tagName":"div","subType":"var","properties":[]},{"key":"Purchase Drawer > Product Badge Inner 3","value":"Free Trial","skipInnerHTML":false,"tagName":"span","subType":"var","properties":[]},{"key":"Purchase Drawer > Product Inner Container 3","value":"","skipInnerHTML":true,"tagName":"div","subType":"var","properties":[]},{"key":"Purchase Drawer > Check Mark Container 3","value":"","skipInnerHTML":true,"tagName":"div","subType":"var","properties":[]},{"key":"Purchase Drawer > Product Content Container 5","value":"","skipInnerHTML":true,"tagName":"div","subType":"var","properties":[]},{"key":"Purchase Drawer > Tertiary Line 1","value":"$0.99","skipInnerHTML":false,"tagName":"p","subType":"var","properties":[]},{"key":"Purchase Drawer > Tertiary Line 2","value":"Line 2","skipInnerHTML":false,"tagName":"p","subType":"var","properties":[]},{"key":"Purchase Drawer > Product Content Container 6","value":"","skipInnerHTML":true,"tagName":"div","subType":"var","properties":[]},{"key":"Purchase Drawer > Tertiary Line 3","value":"Line 3","skipInnerHTML":false,"tagName":"p","subType":"var","properties":[]},{"key":"Purchase Drawer > Tertiary Line 4","value":"Line 4","skipInnerHTML":false,"tagName":"p","subType":"var","properties":[]},{"key":"Purchase Drawer > Purchase Button Container","value":"","skipInnerHTML":true,"tagName":"div","subType":"var","properties":[]},{"key":"Purchase Drawer > Purchase Line One","value":"Start Your Free 7-Day Trial","skipInnerHTML":false,"tagName":"div","subType":"var","properties":[]},{"key":"Purchase Drawer > Purchase Line Two","value":"Line Two","skipInnerHTML":false,"tagName":"div","subType":"var","properties":[{"prefix":"default","property":{"type":"styles","styles":[{"property":"display","value":"none"}]}}]},{"key":"Purchase Drawer > Purchase Subtitle","value":"<div style=\"margin-bottom: 8px;\">AI PRO 6-month</div>\n<div style=\"font-size: 13px; font-weight: 400;\">Free 3-day trial, $59.99 after trial ends</div>","skipInnerHTML":false,"tagName":"p","subType":"var","properties":[{"prefix":"default","property":{"type":"styles","styles":[{"property":"font-size","value":"1rem"},{"property":"font-weight","value":"600"},{"property":"line-height","value":"140%"},{"property":"opacity","value":"1"}]}}]},{"key":"Purchase Drawer > Purchase Button Container 2","value":"","skipInnerHTML":true,"tagName":"div","subType":"var","properties":[]},{"key":"Purchase Drawer > Purchase Line One 2","value":"Purchase Secondary","skipInnerHTML":false,"tagName":"div","subType":"var","properties":[]},{"key":"Purchase Drawer > Purchase Line Two 2","value":"Line Two","skipInnerHTML":false,"tagName":"div","subType":"var","properties":[{"prefix":"default","property":{"type":"styles","styles":[{"property":"display","value":"none"}]}}]},{"key":"Purchase Drawer > Purchase Subtitle 2","value":"secondary selected description","skipInnerHTML":false,"tagName":"p","subType":"var","properties":[]},{"key":"Purchase Drawer > Purchase Button Container 3","value":"","skipInnerHTML":true,"tagName":"div","subType":"var","properties":[]},{"key":"Purchase Drawer > Purchase Line One 3","value":"Purchase Tertiary","skipInnerHTML":false,"tagName":"div","subType":"var","properties":[]},{"key":"Purchase Drawer > Purchase Line Two 3","value":"Line Two","skipInnerHTML":false,"tagName":"div","subType":"var","properties":[{"prefix":"default","property":{"type":"styles","styles":[{"property":"display","value":"none"}]}}]},{"key":"Purchase Drawer > Purchase Subtitle 3","value":"tertiary selected description","skipInnerHTML":false,"tagName":"p","subType":"var","properties":[]},{"key":"Purchase Drawer > Options Button Container","value":"","skipInnerHTML":true,"tagName":"div","subType":"var","properties":[]},{"key":"Purchase Drawer > Pointer","value":"","skipInnerHTML":true,"tagName":"div","subType":"var","properties":[]},{"key":"Purchase Drawer > Options Button","value":"See All Plans","skipInnerHTML":false,"tagName":"p","subType":"var","properties":[{"prefix":"default","property":{"type":"styles","styles":[{"property":"color","value":"hsla(220, 98%, 63%, 1)"}]}}]},{"key":"Purchase Drawer > Hidden","value":"","skipInnerHTML":true,"tagName":"div","subType":"var","properties":[]},{"key":"Purchase Drawer > Text","value":"{{primary.price}}","skipInnerHTML":false,"tagName":"p","subType":"var","properties":[]},{"key":"Purchase Drawer > Text 2","value":"{{secondary.price}}","skipInnerHTML":false,"tagName":"p","subType":"var","properties":[]},{"key":"Purchase Drawer > Text 3","value":"{{tertiary.price}}","skipInnerHTML":false,"tagName":"p","subType":"var","properties":[]},{"key":"Purchase Drawer > Container 2","value":"AI PRO 6-month","skipInnerHTML":false,"tagName":"div","subType":"var","properties":[]},{"key":"Purchase Drawer > Container 3","value":"Free 3-day trial, $59.99 after trial ends","skipInnerHTML":false,"tagName":"div","subType":"var","properties":[]},{"key":"Text __sw-eapa4lzudzal8cfs1ohno","value":"Total Due Today: {{ primary.price }}","freeTrialValue":"Total Due Today: $0.00","skipInnerHTML":false,"tagName":"p","subType":"var","properties":[{"prefix":"default","property":{"type":"styles","styles":[{"property":"text-align","value":"center"}]}}],"initialStyles":{},"revision":1705518316373}]}'
        window.Superwall.afterBuilderLoaded = () => { 
         window.Superwall.configure(JSON.parse(`{"nav":"show","pjs":"https://cdn.superwall.me/runtime/entrypoint.js","font":"","footer":"compact","logoURL":"../public/assets/logo.svg","navLeft":"hide","spacing":"10px","customJS":"let restoreButton = document.querySelector('[data-pw-var=\\\"Div __sw-zpjldarejzcn-9mgugwbj\\\"]');\\nlet swFooterOuterContainer = document.querySelector('#swFooterOuterContainer');\\nswFooterOuterContainer.appendChild(restoreButton);\\n\\nconst primaryButton = document.querySelector('[data-pw-var=\\\"Div __sw-zig-5l9seb8kpgadw7bij\\\"]');\\nconst secondaryButton = document.querySelector('[data-pw-var=\\\"Div __sw-3aeplzh0xxvuk0mcuj2mv\\\"]');\\nconst tertiaryButton = document.querySelector('[data-pw-var=\\\"Div __sw-eemdkqxnkklno-qmwe9bj\\\"]');\\n\\n// When either of the above buttons are clicked, temporarily reduce their size by .1 points\\n\\nprimaryButton.addEventListener('click', () => {\\n    primaryButton.style.transform = 'scale(0.9)';\\n    setTimeout(() => {\\n        primaryButton.style.transform = 'scale(1)';\\n    }, 100);\\n});\\n\\nsecondaryButton.addEventListener('click', () => {\\n    secondaryButton.style.transform = 'scale(0.9)';\\n    setTimeout(() => {\\n        secondaryButton.style.transform = 'scale(1)';\\n    }, 100);\\n});\\n\\ntertiaryButton.addEventListener('click', () => {\\n    tertiaryButton.style.transform = 'scale(0.9)';\\n    setTimeout(() => {\\n        tertiaryButton.style.transform = 'scale(1)';\\n    }, 100);\\n});\\n\\nconst anchorScroll = document.querySelector('[data-pw-var=\\\"Div __sw-bus0t4-o-fj5po1fl9vkj\\\"]');\\nconst allPlansButton = document.querySelector('[data-pw-var=\\\"Text __sw-spi99f-jex79olctcdtld\\\"]');\\n\\n// When you click on the allPlansButton, scroll to the anchorScroll\\nallPlansButton.addEventListener('click', () => {\\n    anchorScroll.scrollIntoView();\\n    }\\n);","fontSize":"calc(min(4.5vw, 1rem))","navRight":"icon","customCSS":".sw-h-divider {\\n  display: none;\\n}\\n\\n.sw-purchase-button {\\n    background: #00D096 !important;\\n}\\n.sw-product-inner-container {\\n    background: white !important;\\n}\\n.sw-dark-overlay {\\n    width: 200vw;\\n    left: -50vw;\\n}\\n\\n[data-pw-var=\\\"Div __sw-zig-5l9seb8kpgadw7bij\\\"] {\\n  transition: transform .1s;\\n}\\n\\n[data-pw-var=\\\"Div __sw-3aeplzh0xxvuk0mcuj2mv\\\"] {\\n  transition: transform .1s;\\n}\\n\\n[data-pw-var=\\\"Div __sw-eemdkqxnkklno-qmwe9bj\\\"] {\\n  transition: transform .1s;\\n}\\n\\n[data-pw-var=\\\"ImageBase __sw-jowhuuamkeaz22mrxolrk\\\"] {\\n  object-fit: contain;\\n}\\n\\n.main-heading {\\n  color: #000;\\n  font-family: Inter;\\n  font-size: 25px;\\n  font-style: normal;\\n  font-weight: 400;\\n  line-height: 100%; /* 25px */\\n  letter-spacing: -0.5px;\\n  text-transform: capitalize;\\n}\\n\\n.accent-heading {\\n  color: #4481FD;\\n  font-family: Inter;\\n  font-size: 30px;\\n  font-style: normal;\\n  font-weight: 700;\\n  line-height: 100%;\\n  letter-spacing: -0.6px;\\n  text-transform: capitalize;\\n}","direction":"vertical","navCenter":"hide","brandColor":"hsla(220, 98%, 63%, 1)","logoHeight":"35px","badgeRadius":"8px","borderColor":"rgba(255, 255, 255, 1)","borderWidth":"0px","cardPadding":"calc(var(--sw-spacing) * 1.6)","googleFonts":"","headingFont":"","navPosition":"fixed","hideProducts":"true","productCount":"one","footerDivider":"hide","forceDarkMode":"false","productRadius":"12px","brandTextColor":"#FFFFFF","contentPadding":"calc(var(--sw-spacing) * 1.6)","footerPosition":"inline","navLeftIconURL":"../public/assets/nav-button.svg","productDivider":"show","productPadding":"15px","purchaseRadius":"15px","useCustomFonts":"false","backgroundColor":"rgba(19, 20, 23, 0.7)","checkMarkMargin":"0 12px 0 4px","containerRadius":"24px","footerAlignment":"center","foregroundColor":"hsla(220, 41%, 25%, 1)","minNavbarHeight":"64px","navRightIconURL":"../public/assets/nav-button.svg","paywallMaxWidth":"500px","previewDarkMode":"false","sectionPaddingX":"0px","sectionPaddingY":"0px","contentAlignment":"top","insetsTopContent":"false","reverseDirection":"false","statusBarPadding":"34px","navBackgroundBlur":"false","cardBackgroundBlur":"true","navBackgroundColor":"auto","navButtonIconsSize":"42px","productDescription":"show","brandSecondaryColor":"","navLeftInnerIconURL":"../public/assets/nav-button.svg","primaryProductBadge":"hide","selectedBorderWidth":"2px","navRightInnerIconURL":"../public/assets/nav-button.svg","showProductCheckMark":"hide","tertiaryProductBadge":"hide","buttonBackgroundColor":"","purchaseButtonLineTwo":"show","secondaryProductBadge":"hide","selectedCheckBoxImage":"https://static.superwallassets.com/uoQsDwmrnamiqkfkzRKvC","paywallBackgroundColor":"hsla(210, 100%, 98%, 1)","productBackgroundColor":"rgba(0,0,0,0.85)","hideFixedPurchaseDrawer":"true","unselectedCheckBoxImage":"https://static.superwallassets.com/ElRGbHkiRQTvFQ3Gojbfu","backgroundContentMaxWidth":"paywallMaxWidth","autoAdjustContentAlignment":"true"}`))
          window.Superwall.setDom(JSON.parse(`{"version":11,"cardContent":[],"mainContent":[{"id":"__sw-Bus0t4-o-FJ5PO1fL9VKJ","name":"div","children":[{"id":"__sw-tA6PjCkg5ghYCJNgra4Nk","name":"heading","settings":{"type":"h1","initialStyles":{}}},{"id":"__sw-JOwhuUamkEaZ22mrXOlRk","name":"imageBase","settings":{"src":"https://static.superwallassets.com/Lk-TIJDEE3wlSfp47vmCC","altText":"Image","initialStyles":{"width":"100%","height":"auto"}}}],"settings":{"style":"","initialStyles":{}}},{"id":"__sw-CSw4b0gWK_SW3sVFL6OI8","name":"section","children":[{"id":"__sw-tVerTPlbBsCssL0wt3FTW","name":"text","settings":{"text":"","isParagraph":false,"initialStyles":{}}},{"id":"__sw-55GIV9tcNtVxdD94-6xhk","name":"div","children":[{"id":"__sw-bt0B6klxzoqSILeWSk-BB","name":"timeline","children":[{"id":"__sw--axDDtLE8vY_CmatbV1cg","name":"timelineItem","settings":{"style":"","isLast":false,"iconUrl":"../public/assets/t-check.svg","hideIcons":false,"iconWidth":24,"showCheck":false,"trailStyle":"","gutterWidth":"16px","bulletRadius":999,"contentStyle":"","primaryColor":"var(--sw-brand-color)","checkmarkIcon":"mojo/check.svg","subtitleStyle":"","secondaryColor":"var(--sw-brand-color)","isStepCompleted":false,"iconContainerWidth":40,"iconContainerShadow":"0px 0px 0px 0px rgba(0, 0, 0, 0.0)"},"container":{"blur":false,"card":false,"badge":false,"bleed":false,"cover":false,"inset":false,"light":false,"style":"","width":"100%","height":"auto","noMargin":false,"fullWidth":false,"noPadding":false,"textAlign":"left","textColor":"","cardRadius":"16px","fullHeight":false,"lightBleed":false,"bleedBottom":false,"lightMargin":false,"showDivider":false,"heavyPadding":false,"lightPadding":false,"noBackground":false,"noTopPadding":false,"backgroundColor":"","backgroundImage":"","bleedBackground":false,"extraLightBleed":false,"backgroundOpacity":1}},{"id":"__sw-zsVVoZBWfaXZitvuFQKy9","name":"timelineItem","settings":{"style":"","isLast":false,"iconUrl":"../public/assets/t-check.svg","hideIcons":false,"iconWidth":24,"showCheck":false,"trailStyle":"","gutterWidth":"var(--sw-container-padding)","bulletRadius":999,"contentStyle":"","primaryColor":"var(--sw-brand-color)","checkmarkIcon":"mojo/check.svg","subtitleStyle":"","secondaryColor":"var(--sw-brand-color)","isStepCompleted":false,"iconContainerWidth":40,"iconContainerShadow":"0px 0px 0px 0px rgba(0, 0, 0, 0.0)"},"container":{"blur":false,"card":false,"badge":false,"bleed":false,"cover":false,"inset":false,"light":false,"style":"","width":"100%","height":"auto","noMargin":false,"fullWidth":false,"noPadding":false,"textAlign":"left","textColor":"","cardRadius":"16px","fullHeight":false,"lightBleed":false,"bleedBottom":false,"lightMargin":false,"showDivider":false,"heavyPadding":false,"lightPadding":false,"noBackground":false,"noTopPadding":false,"backgroundColor":"","backgroundImage":"","bleedBackground":false,"extraLightBleed":false,"backgroundOpacity":1}},{"id":"__sw-3QwSfYiIrkN_sJX2Fk63w","name":"timelineItem","settings":{"style":"","isLast":true,"iconUrl":"../public/assets/t-check.svg","hideIcons":false,"iconWidth":24,"showCheck":false,"trailStyle":"","gutterWidth":"16px","bulletRadius":999,"contentStyle":"","primaryColor":"var(--sw-brand-color)","checkmarkIcon":"mojo/check.svg","subtitleStyle":"","secondaryColor":"var(--sw-brand-color)","isStepCompleted":false,"iconContainerWidth":40,"iconContainerShadow":"0px 0px 0px 0px rgba(0, 0, 0, 0.0)"},"container":{"blur":false,"card":false,"badge":false,"bleed":false,"cover":false,"inset":false,"light":false,"style":"","width":"100%","height":"auto","noMargin":false,"fullWidth":false,"noPadding":false,"textAlign":"left","textColor":"","cardRadius":"16px","fullHeight":false,"lightBleed":false,"bleedBottom":false,"lightMargin":false,"showDivider":false,"heavyPadding":false,"lightPadding":false,"noBackground":false,"noTopPadding":false,"backgroundColor":"","backgroundImage":"","bleedBackground":false,"extraLightBleed":false,"backgroundOpacity":1}}],"container":{"blur":false,"card":false,"badge":false,"bleed":false,"cover":false,"inset":false,"light":false,"style":"","width":"100%","height":"auto","noMargin":true,"fullWidth":false,"noPadding":false,"textAlign":"left","textColor":"","cardRadius":"16px","fullHeight":false,"lightBleed":false,"bleedBottom":false,"lightMargin":false,"showDivider":false,"heavyPadding":false,"lightPadding":false,"noBackground":false,"noTopPadding":false,"backgroundColor":"","backgroundImage":"","bleedBackground":false,"extraLightBleed":false,"backgroundOpacity":1}}],"settings":{"style":"","initialStyles":{}}}]},{"id":"__sw-d43-MDe0XYrshsPgsp7_g","name":"section","children":[{"id":"__sw-rT--K-jSikuTutOywmf-B","name":"text","settings":{"text":"","isParagraph":false,"initialStyles":{}}},{"id":"__sw-4FdtIZtnlZlPspXOnFmOb","name":"div","children":[{"id":"__sw-qXdXPUghNgUOiB0ZwUk7F","name":"div","children":[{"id":"__sw-3jyjADimqYqGDAhHZYosa","name":"text","settings":{"text":"","isParagraph":false,"initialStyles":{}}},{"id":"__sw-eemDkQxnKKlNO-qmwe9BJ","name":"div","children":[{"id":"__sw-TgVzw1eiPDcc-aQ6uYDA-","name":"text","settings":{"text":"","isParagraph":false,"initialStyles":{}}},{"id":"__sw-VVrKiGLOCY3RqpGfb2DWS","name":"text","settings":{"text":"","isParagraph":false,"initialStyles":{}}},{"id":"__sw-b_KSu4QwFxndZNIUvS3c1","name":"text","settings":{"text":"","isParagraph":false,"initialStyles":{}}},{"id":"__sw-4LxCHaF6g1W8UMsFEuwFp","name":"text","settings":{"text":"","isParagraph":false,"initialStyles":{}}},{"id":"__sw--pgDtY5QY4cTNVR9HG1Qk","name":"text","settings":{"text":"","isParagraph":false,"initialStyles":{}}},{"id":"__sw-Z9pUWooyWnXilSzj5JTrM","name":"div","children":[],"settings":{"style":"","initialStyles":{}}},{"id":"__sw-MSXk1uZuAboxo_76G-eYd","name":"text","settings":{"text":"","isParagraph":false,"initialStyles":{}}},{"id":"__sw-SeNqO-Ti5KC25VO0k5OJT","name":"text","settings":{"text":"","isParagraph":false,"initialStyles":{}}}],"settings":{"style":"","initialStyles":{}}},{"id":"__sw-rcCfRLCVhYkvuc_Y17GLM","name":"text","settings":{"text":"","isParagraph":false,"initialStyles":{}}}],"settings":{"style":"","initialStyles":{}}},{"id":"__sw-GhgNh_kni_MGcrxR7Wsgt","name":"div","children":[{"id":"__sw--4dw1pmc2qbX96jkVHldL","name":"text","settings":{"text":"","isParagraph":false,"initialStyles":{}}},{"id":"__sw-3aEplZH0XxvUk0mCUJ2MV","name":"div","children":[{"id":"__sw-V1AgX52sQhFh_LeAplh55","name":"text","settings":{"text":"","isParagraph":false,"initialStyles":{}}},{"id":"__sw-v2kx_WJVwcSW2PQZP4QIb","name":"text","settings":{"text":"","isParagraph":false,"initialStyles":{}}},{"id":"__sw-H-HDzHMAEkKT9L6v0HYog","name":"text","settings":{"text":"","isParagraph":false,"initialStyles":{}}},{"id":"__sw-qJmFqP59BDqi1Mb4hMBnu","name":"text","settings":{"text":"","isParagraph":false,"initialStyles":{}}},{"id":"__sw-NZu3PxQbwhUSV_9KHIIm7","name":"text","settings":{"text":"","isParagraph":false,"initialStyles":{}}},{"id":"__sw-zkKuKwAkHy9TmBhTj7So0","name":"div","children":[],"settings":{"style":"","initialStyles":{}}},{"id":"__sw-7aeSVue6zlcLd9K-KKRf7","name":"text","settings":{"text":"","isParagraph":false,"initialStyles":{}}},{"id":"__sw-gtOcF_uiBRqikC2yYorh4","name":"text","settings":{"text":"","isParagraph":false,"initialStyles":{}}}],"settings":{"style":"","initialStyles":{}}},{"id":"__sw-2e7MAatqw5kMlByB0eN0e","name":"text","settings":{"text":"","isParagraph":false,"initialStyles":{}}}],"settings":{"style":"","initialStyles":{}}},{"id":"__sw-hF1IQc3SY_PFfHPx0B4vv","name":"div","children":[{"id":"__sw-FB_-Q_X5u6ZD_4fK-HvOc","name":"text","settings":{"text":"","isParagraph":false,"initialStyles":{}}},{"id":"__sw-zig-5l9seb8kPgaDw7BiJ","name":"div","children":[{"id":"__sw-FsybKQCZaa0iIo8lPzc2Y","name":"text","settings":{"text":"","isParagraph":false,"initialStyles":{}}},{"id":"__sw-Xb_R2rsy-8G18ARAE4V8S","name":"text","settings":{"text":"","isParagraph":false,"initialStyles":{}}},{"id":"__sw-llwVX9m1-b1HJ5CQNhy3j","name":"text","settings":{"text":"","isParagraph":false,"initialStyles":{}}},{"id":"__sw-Nyvy9YCzkXypJaxs8egvq","name":"text","settings":{"text":"","isParagraph":false,"initialStyles":{}}},{"id":"__sw-gvGgK098u8pvm83HFOnhl","name":"text","settings":{"text":"","isParagraph":false,"initialStyles":{}}},{"id":"__sw-ogzWEzXpR2wdEcPOm4aq9","name":"div","children":[],"settings":{"style":"","initialStyles":{}}},{"id":"__sw-DCAvhaY8qQn81XEqmBIQI","name":"text","settings":{"text":"","isParagraph":false,"initialStyles":{}}},{"id":"__sw-QWStEWKS3CeEbL39K8VxL","name":"text","settings":{"text":"","isParagraph":false,"initialStyles":{}}}],"settings":{"style":"","initialStyles":{}}},{"id":"__sw-yYGSr8Zug8OnMw_YTTqUS","name":"text","settings":{"text":"","isParagraph":false,"initialStyles":{}}}],"settings":{"style":"","initialStyles":{}}}],"settings":{"style":"","initialStyles":{}}}]},{"id":"__sw-tkV5-4J-S6pzZBUM2xPJ-","name":"section","children":[{"id":"__sw-PFRCX444pq9vwJZhUthaH","name":"text","settings":{"text":"","isParagraph":false,"initialStyles":{}}},{"id":"__sw-uqdbmRNhmzouG7TZyTzgg","name":"div","children":[{"id":"__sw-_FiZLSuWLdvX44BrEsxi5","name":"div","children":[{"id":"__sw-EXJBs2Dv4NxUJv1mI_I1Z","name":"text","settings":{"text":"","isParagraph":false,"initialStyles":{}}},{"id":"__sw-GVtMgQvhoU8nGrVJj0_t8","name":"text","settings":{"text":"","isParagraph":false,"initialStyles":{}}},{"id":"__sw-mo_RHLQht3lYfeU-1eKoN","name":"div","children":[{"id":"__sw-3Aoj6yE-NaXfeMkb9-N-J","name":"div","children":[{"id":"__sw-TcZxOQjxmDvti6yXx375F","name":"imageBase","settings":{"src":"https://static.superwallassets.com/LMbCJMM4kgLB1Zy7yWzIH","altText":"Image","initialStyles":{"width":"100%","height":"auto"}}},{"id":"__sw-EB8qLg0ABRNEkOn_Llk-q","name":"text","settings":{"text":"","isParagraph":false,"initialStyles":{}}}],"settings":{"style":"","initialStyles":{}}},{"id":"__sw-Lq5_VAGeudaNmtSf5v1vG","name":"div","children":[{"id":"__sw-1rmP4KtQjeb9EFbUobH1I","name":"imageBase","settings":{"src":"https://static.superwallassets.com/Qx1wuxwanlG92i0DuAbaZ","altText":"Image","initialStyles":{"width":"100%","height":"auto"}}},{"id":"__sw-eH9pzLm1dUyvdN7-x3BTj","name":"text","settings":{"text":"","isParagraph":false,"initialStyles":{}}}],"settings":{"style":"","initialStyles":{}}},{"id":"__sw-aIZs9P1uzzV1rX_QDoG78","name":"div","children":[{"id":"__sw-l9fnRzDL9FxCpHWIvHk1B","name":"imageBase","settings":{"src":"https://static.superwallassets.com/oea3YAyfYJa04Wop0Ausp","altText":"Image","initialStyles":{"width":"100%","height":"auto"}}},{"id":"__sw-P_5eHkodjsaw5SZFWjHay","name":"text","settings":{"text":"","isParagraph":false,"initialStyles":{}}}],"settings":{"style":"","initialStyles":{}}}],"settings":{"style":"","initialStyles":{}}},{"id":"__sw-wZf7VT0x5qWM_8sUk2Gxo","name":"div","children":[{"id":"__sw-EFvUHb7YXIrM-nqWNkhuq","name":"div","children":[{"id":"__sw-c3zjE9RKoeJ-K9ed3KeYU","name":"imageBase","settings":{"src":"https://static.superwallassets.com/rSPb2Eq9RSGWBwSl-749m","altText":"Image","initialStyles":{"width":"100%","height":"auto"}}},{"id":"__sw-IUZ7ahnwuJuMdpg5DQnOY","name":"text","settings":{"text":"","isParagraph":false,"initialStyles":{}}}],"settings":{"style":"","initialStyles":{}}},{"id":"__sw-U0e-dQkKm4i6xWN_V1_aW","name":"div","children":[{"id":"__sw-isk31vD6ao34kZlbA6a4b","name":"imageBase","settings":{"src":"https://static.superwallassets.com/rSPb2Eq9RSGWBwSl-749m","altText":"Image","initialStyles":{"width":"100%","height":"auto"}}},{"id":"__sw-uKV5y0M2ZYlAttqQKJrfX","name":"text","settings":{"text":"","isParagraph":false,"initialStyles":{}}}],"settings":{"style":"","initialStyles":{}}},{"id":"__sw-eQFssUcFeFzQxS7ZpIPaP","name":"div","children":[{"id":"__sw-elWjHutVg5iyiQDWc4vzb","name":"imageBase","settings":{"src":"https://static.superwallassets.com/rSPb2Eq9RSGWBwSl-749m","altText":"Image","initialStyles":{"width":"100%","height":"auto"}}},{"id":"__sw-hzY8TNpLWCjQT10YUPKdY","name":"text","settings":{"text":"","isParagraph":false,"initialStyles":{}}}],"settings":{"style":"","initialStyles":{}}},{"id":"__sw-Kvm6_hxB-ZO8L_Z_cLLr8","name":"div","children":[{"id":"__sw-a0w99pzsKf2YTRFbxWWqq","name":"imageBase","settings":{"src":"https://static.superwallassets.com/rSPb2Eq9RSGWBwSl-749m","altText":"Image","initialStyles":{"width":"100%","height":"auto"}}},{"id":"__sw-fls8uItO7O5LPiNQOAtUi","name":"text","settings":{"text":"","isParagraph":false,"initialStyles":{}}}],"settings":{"style":"","initialStyles":{}}},{"id":"__sw-aemuuEeg3Xsrqh_OvEGDt","name":"div","children":[{"id":"__sw-i0Uxzt-H50vzZ46-4UcE0","name":"imageBase","settings":{"src":"https://static.superwallassets.com/ut1Ks9EWe-fCS7MbxxaMe","altText":"Image","initialStyles":{"width":"100%","height":"auto"}}},{"id":"__sw-yM90ZLUnCy3VWYViT0k1J","name":"text","settings":{"text":"","isParagraph":false,"initialStyles":{}}}],"settings":{"style":"","initialStyles":{}}}],"settings":{"style":"","initialStyles":{}}}],"settings":{"style":"","initialStyles":{}}},{"id":"__sw-ocfDfZcXmzucRGXtr-oX2","name":"div","children":[{"id":"__sw-A4y9knuJoP9rfhGza6ti5","name":"text","settings":{"text":"","isParagraph":false,"initialStyles":{}}},{"id":"__sw-rAmu2XP_kr5iFs5N5gj-e","name":"text","settings":{"text":"","isParagraph":false,"initialStyles":{}}},{"id":"__sw-eDz4IxlPZeN_4qvLqb2hX","name":"div","children":[{"id":"__sw-TlIukBusD7t0EPuSk296u","name":"div","children":[{"id":"__sw-xvPMln5MHGNR2KOYyPhzD","name":"imageBase","settings":{"src":"https://static.superwallassets.com/mZAhiKE3pdp7evLuk2wa8","altText":"Image","initialStyles":{"width":"100%","height":"auto"}}},{"id":"__sw-d6XV9RzZwjl2n_iszwPXF","name":"text","settings":{"text":"","isParagraph":false,"initialStyles":{}}}],"settings":{"style":"","initialStyles":{}}},{"id":"__sw-eundXgZj-M_cVChB1nLaA","name":"div","children":[{"id":"__sw-tlvDaX8RCA6oqZWHznNH7","name":"imageBase","settings":{"src":"https://static.superwallassets.com/Qx1wuxwanlG92i0DuAbaZ","altText":"Image","initialStyles":{"width":"100%","height":"auto"}}},{"id":"__sw--Wc-jVv8fU4S08VwSBtXY","name":"text","settings":{"text":"","isParagraph":false,"initialStyles":{}}}],"settings":{"style":"","initialStyles":{}}},{"id":"__sw-rjt0_xd6IaNJL4bXFxdFx","name":"div","children":[{"id":"__sw-kNz9Y9RLXJ0lpoZJbSTfF","name":"imageBase","settings":{"src":"https://static.superwallassets.com/lbmKB4flMlfP0OVqoosVc","altText":"Image","initialStyles":{"width":"100%","height":"auto"}}},{"id":"__sw-w4nP6f_ikM1NbCiQO5eH5","name":"text","settings":{"text":"","isParagraph":false,"initialStyles":{}}}],"settings":{"style":"","initialStyles":{}}}],"settings":{"style":"","initialStyles":{}}},{"id":"__sw-X3RMy77Lmn1AJdnw4SBm2","name":"div","children":[{"id":"__sw-u_7M0dA3p_x9MIg9fgxK_","name":"div","children":[{"id":"__sw-rAOtuIs6wENrAouyUjtey","name":"imageBase","settings":{"src":"https://static.superwallassets.com/4055G-MNuHlk6yABOKwBB","altText":"Image","initialStyles":{"width":"100%","height":"auto"}}},{"id":"__sw-qyQGAQYiZYMCW2U1EHojF","name":"text","settings":{"text":"","isParagraph":false,"initialStyles":{}}}],"settings":{"style":"","initialStyles":{}}},{"id":"__sw-iq5bzVwt22W5aY3zk5LUN","name":"div","children":[{"id":"__sw-C92KcbvVLpr6MN2skjTxJ","name":"imageBase","settings":{"src":"https://static.superwallassets.com/4055G-MNuHlk6yABOKwBB","altText":"Image","initialStyles":{"width":"100%","height":"auto"}}},{"id":"__sw-jiyajTh2aQLU8snRinJ0M","name":"text","settings":{"text":"","isParagraph":false,"initialStyles":{}}}],"settings":{"style":"","initialStyles":{}}},{"id":"__sw-1NWAbCDSqc-buPw44MhuC","name":"div","children":[{"id":"__sw-Sljkg4ku5va25o7_IoC8Z","name":"imageBase","settings":{"src":"https://static.superwallassets.com/4055G-MNuHlk6yABOKwBB","altText":"Image","initialStyles":{"width":"100%","height":"auto"}}},{"id":"__sw-CYzrNG0aO4jiPqFfvbHR6","name":"text","settings":{"text":"","isParagraph":false,"initialStyles":{}}}],"settings":{"style":"","initialStyles":{}}},{"id":"__sw-lQ7GRnTnhUQes7yDQ_e8F","name":"div","children":[{"id":"__sw-D9EAlyTfWdJRR0GDkt206","name":"imageBase","settings":{"src":"https://static.superwallassets.com/4055G-MNuHlk6yABOKwBB","altText":"Image","initialStyles":{"width":"100%","height":"auto"}}},{"id":"__sw-OtJFrW2A6fl7O6cCfY3EX","name":"text","settings":{"text":"","isParagraph":false,"initialStyles":{}}}],"settings":{"style":"","initialStyles":{}}}],"settings":{"style":"","initialStyles":{}}}],"settings":{"style":"","initialStyles":{}}},{"id":"__sw-LxCBUdDGkx2u4TAIOwmxv","name":"div","children":[{"id":"__sw-wG4B09PBmAwSOrVtBWNER","name":"text","settings":{"text":"","isParagraph":false,"initialStyles":{}}},{"id":"__sw-DUrNH87KA4h7OEcV9rj-f","name":"text","settings":{"text":"","isParagraph":false,"initialStyles":{}}},{"id":"__sw-iCN1wBoCsVa57afF3gwwH","name":"div","children":[{"id":"__sw-obUJXbIj8F4Z-ZftBAaJ-","name":"div","children":[{"id":"__sw-5nkyBgHhTPHFwUEIFjXr5","name":"imageBase","settings":{"src":"https://static.superwallassets.com/d533qdTpVL9W8Tf6XWqzv","altText":"Image","initialStyles":{"width":"100%","height":"auto"}}}],"settings":{"style":"","initialStyles":{}}},{"id":"__sw-VMnEyrUbjMreafKSxHe2h","name":"div","children":[{"id":"__sw-OAtsU64NfteXalTASNMNK","name":"imageBase","settings":{"src":"https://static.superwallassets.com/mzM24ZEULUc8RcZ8oqE0Z","altText":"Image","initialStyles":{"width":"100%","height":"auto"}}},{"id":"__sw-JBKA0nRPhfPnEK66rhYRt","name":"text","settings":{"text":"","isParagraph":false,"initialStyles":{}}}],"settings":{"style":"","initialStyles":{}}},{"id":"__sw-0NufusddJ_zzzvwFM26jL","name":"div","children":[{"id":"__sw-jmY7KGE9ZMp9kw02lP3g-","name":"imageBase","settings":{"src":"https://static.superwallassets.com/jLfkrG7yS_UZELC45PoGw","altText":"Image","initialStyles":{"width":"100%","height":"auto"}}},{"id":"__sw-CjyLY4Y00KPIuFHY2R-WZ","name":"text","settings":{"text":"","isParagraph":false,"initialStyles":{}}}],"settings":{"style":"","initialStyles":{}}}],"settings":{"style":"","initialStyles":{}}},{"id":"__sw-mA7pBnzXrpnYg3XNbwib-","name":"div","children":[{"id":"__sw-Ud5pOWiBHaB4L7ahxBGiL","name":"div","children":[{"id":"__sw-SPlryaq2tHMyETlekyBF8","name":"imageBase","settings":{"src":"https://static.superwallassets.com/ut1Ks9EWe-fCS7MbxxaMe","altText":"Image","initialStyles":{"width":"100%","height":"auto"}}},{"id":"__sw-xhid3LYtDLeRTuW7tP0yd","name":"text","settings":{"text":"","isParagraph":false,"initialStyles":{}}}],"settings":{"style":"","initialStyles":{}}},{"id":"__sw-4ipQ2Rk0OSQvDgLA__ykz","name":"div","children":[{"id":"__sw-zWPqwXa60xp2-6NgGUJwm","name":"imageBase","settings":{"src":"https://static.superwallassets.com/ut1Ks9EWe-fCS7MbxxaMe","altText":"Image","initialStyles":{"width":"100%","height":"auto"}}},{"id":"__sw--gmXn9mA44kiUZo5WxqqA","name":"text","settings":{"text":"","isParagraph":false,"initialStyles":{}}}],"settings":{"style":"","initialStyles":{}}},{"id":"__sw-TJLj3acV_U6v-KSWz1eTt","name":"div","children":[{"id":"__sw-bq4awiQAJaNsK6SMbX3Ik","name":"imageBase","settings":{"src":"https://static.superwallassets.com/ut1Ks9EWe-fCS7MbxxaMe","altText":"Image","initialStyles":{"width":"100%","height":"auto"}}},{"id":"__sw-0Xjad4GKkyeKS6QOOfBwC","name":"text","settings":{"text":"","isParagraph":false,"initialStyles":{}}}],"settings":{"style":"","initialStyles":{}}},{"id":"__sw-vgdW5aaVkEiOc7kOR4Yie","name":"div","children":[{"id":"__sw-vc9bMEUtUAS1ofIKP9VYL","name":"imageBase","settings":{"src":"https://static.superwallassets.com/ut1Ks9EWe-fCS7MbxxaMe","altText":"Image","initialStyles":{"width":"100%","height":"auto"}}},{"id":"__sw-XW-IKWArCAh6kxva_3bJR","name":"text","settings":{"text":"","isParagraph":false,"initialStyles":{}}}],"settings":{"style":"","initialStyles":{}}},{"id":"__sw-ipBfGIx2LZ1cuyuPhNZxz","name":"div","children":[{"id":"__sw-OK2qO6wiavV5fNsaNGwYW","name":"imageBase","settings":{"src":"https://static.superwallassets.com/ut1Ks9EWe-fCS7MbxxaMe","altText":"Image","initialStyles":{"width":"100%","height":"auto"}}},{"id":"__sw-fcciJr4oWIqEzsLIux3x3","name":"text","settings":{"text":"","isParagraph":false,"initialStyles":{}}}],"settings":{"style":"","initialStyles":{}}}],"settings":{"style":"","initialStyles":{}}}],"settings":{"style":"","initialStyles":{}}}],"settings":{"style":"","initialStyles":{}}}]},{"id":"__sw-LW1H1qMC4Nx9-dKkAN36B","name":"section","children":[{"id":"__sw-UBwLrGDqNbDKmIjGt1i66","name":"text","settings":{"text":"","isParagraph":false,"initialStyles":{}}},{"id":"__sw-iuA2Dssu6YzsxJKk8kM7b","name":"listV2","children":[{"id":"__sw-aUZgHQbJhebfSjV3h1_Gn","name":"review","settings":{"stars":5,"style":"","minimal":false,"bottomAuthor":false},"container":{"blur":false,"card":true,"badge":false,"bleed":false,"cover":false,"inset":false,"light":false,"style":"","width":"100%","height":"auto","noMargin":true,"fullWidth":false,"noPadding":false,"textAlign":"left","textColor":"","cardRadius":"16px","fullHeight":false,"lightBleed":false,"bleedBottom":false,"lightMargin":false,"showDivider":false,"heavyPadding":false,"lightPadding":false,"noBackground":false,"noTopPadding":false,"backgroundColor":"","backgroundImage":"","bleedBackground":false,"extraLightBleed":false,"backgroundOpacity":1}},{"id":"__sw-3K6yM6_Gaa9ioynYz1jbO","name":"review","settings":{"stars":5,"style":"","minimal":false,"bottomAuthor":false},"container":{"blur":false,"card":true,"badge":false,"bleed":false,"cover":false,"inset":false,"light":false,"style":"","width":"100%","height":"auto","noMargin":true,"fullWidth":false,"noPadding":false,"textAlign":"left","textColor":"","cardRadius":"16px","fullHeight":false,"lightBleed":false,"bleedBottom":false,"lightMargin":false,"showDivider":false,"heavyPadding":false,"lightPadding":false,"noBackground":false,"noTopPadding":false,"backgroundColor":"","backgroundImage":"","bleedBackground":false,"extraLightBleed":false,"backgroundOpacity":1}},{"id":"__sw-o3nQKSc-Y2bikYYXZFoXw","name":"review","settings":{"stars":5,"style":"","minimal":false,"bottomAuthor":false},"container":{"blur":false,"card":true,"badge":false,"bleed":false,"cover":false,"inset":false,"light":false,"style":"","width":"100%","height":"auto","noMargin":true,"fullWidth":false,"noPadding":false,"textAlign":"left","textColor":"","cardRadius":"16px","fullHeight":false,"lightBleed":false,"bleedBottom":false,"lightMargin":false,"showDivider":false,"heavyPadding":false,"lightPadding":false,"noBackground":false,"noTopPadding":false,"backgroundColor":"","backgroundImage":"","bleedBackground":false,"extraLightBleed":false,"backgroundOpacity":1}},{"id":"__sw-vY8Ybw0OYoABZA0P3CtfN","name":"review","settings":{"stars":5,"style":"","minimal":false,"bottomAuthor":false},"container":{"blur":false,"card":true,"badge":false,"bleed":false,"cover":false,"inset":false,"light":false,"style":"","width":"100%","height":"auto","noMargin":true,"fullWidth":false,"noPadding":false,"textAlign":"left","textColor":"","cardRadius":"16px","fullHeight":false,"lightBleed":false,"bleedBottom":false,"lightMargin":false,"showDivider":false,"heavyPadding":false,"lightPadding":false,"noBackground":false,"noTopPadding":false,"backgroundColor":"","backgroundImage":"","bleedBackground":false,"extraLightBleed":false,"backgroundOpacity":1}}],"settings":{"snap":true,"style":"","height":"auto","fullHeight":false,"horizontal":true,"hasItemPadding":true,"indicatorColor":"#ffffff","indicatorTopPadding":true,"indicatorBottomPadding":true},"container":{"blur":false,"card":false,"badge":false,"bleed":false,"cover":false,"inset":false,"light":false,"style":"","width":"100%","height":"auto","noMargin":true,"fullWidth":false,"noPadding":false,"textAlign":"left","textColor":"","cardRadius":"16px","fullHeight":false,"lightBleed":false,"bleedBottom":false,"lightMargin":false,"showDivider":false,"heavyPadding":false,"lightPadding":false,"noBackground":false,"noTopPadding":false,"backgroundColor":"","backgroundImage":"","bleedBackground":false,"extraLightBleed":false,"backgroundOpacity":1},"childrenContainer":{"cover":false,"style":"","width":"100%","height":"auto","noMargin":false,"fullWidth":false,"fullHeight":false,"noBackground":false}}]},{"id":"__sw-0wIhk5QzVYEudUEHcn1G_","name":"section","children":[{"id":"__sw-wOH9qKd6A_knfJOb3ZYf3","name":"text","settings":{"text":"","isParagraph":false,"initialStyles":{}}},{"id":"__sw-j3ojjYJ0XR7J8HfE57LsB","name":"div","children":[{"id":"__sw-x_hBoMIkqvhpAyS9YGx9X","name":"imageBase","settings":{"src":"https://static.superwallassets.com/XkTPBQJWwCqMh998eDqSi","altText":"Image","initialStyles":{"width":"100%","height":"auto"}}},{"id":"__sw-c_CsYnKF6e-5F1L2dBF-Z","name":"text","settings":{"text":"","isParagraph":false,"initialStyles":{}}},{"id":"__sw-6hT8JwykpXOizZx9r5ZAe","name":"text","settings":{"text":"","isParagraph":false,"initialStyles":{}}},{"id":"__sw-aTzjS7wzO3S1lEF6bZkP_","name":"buttonBase"}],"settings":{"style":"","initialStyles":{}}}]},{"id":"__sw-ZpjLDAREJZcN-9MgUgwBJ","name":"div","children":[{"id":"__sw-Zp7Cgy3o6Xg8vgg6wtbnt","name":"text","settings":{"text":"","isParagraph":false,"initialStyles":{}}},{"id":"__sw-5G9WT12cJAbkL30VFuHDq","name":"div","children":[{"id":"__sw-0H7LR61cYBzwG78KCiMso","name":"text","settings":{"text":"Terms","isParagraph":false,"initialStyles":{"display":"inline-block","padding":"0px calc(var(--sw-font-size) * 0.125)","fontSize":"calc(var(--sw-font-size) * 0.75);"}}},{"id":"__sw-3K9SE29eCMpfI86XEzIsp","name":"text","settings":{"text":"&","isParagraph":false,"initialStyles":{"display":"inline-block","padding":"0px calc(var(--sw-font-size) * 0.125)","fontSize":"calc(var(--sw-font-size) * 0.75);"}}},{"id":"__sw-CciGJVtJd9EkxMr7IFeT1","name":"text","settings":{"text":"Privacy","isParagraph":false,"initialStyles":{"display":"inline-block","padding":"0px calc(var(--sw-font-size) * 0.125)","fontSize":"calc(var(--sw-font-size) * 0.75);"}}},{"id":"__sw-LroCOEtVyOEjxP93VNw0K","name":"text","settings":{"text":"|","isParagraph":false,"initialStyles":{"display":"inline-block","padding":"0px calc(var(--sw-font-size) * 0.125)","fontSize":"calc(var(--sw-font-size) * 0.75);"}}},{"id":"__sw-8JwCiWIf9E2j8JdwOOc07","name":"text","settings":{"text":"Renews for $0.00 per day","isParagraph":false,"initialStyles":{"display":"inline-block","padding":"0px calc(var(--sw-font-size) * 0.125)","fontSize":"calc(var(--sw-font-size) * 0.75);"}}}],"settings":{"style":"","initialStyles":{"display":"flex","alignItems":"center","paddingTop":"calc(var(--sw-container-padding) * 0.6)","flexDirection":"row","paddingBottom":"calc(var(--sw-container-padding) * 0.6)","justifyContent":"center"}},"customName":"Footer"}],"settings":{"style":"","initialStyles":{}}},{"id":"__sw-0E8JE29eCMpfI86XEzTrw","name":"drawer","children":[{"id":"__sw-eaPA4lzuDzAl8cFs1ohnO","name":"text","settings":{"text":"","isParagraph":false,"initialStyles":{}}},{"id":"__sw-FxoDJNtKhOQjxMh7INqF5","name":"products","settings":{"direction":"vertical","borderColor":"rgba(255, 255, 255, 1)","borderWidth":"0px","hideProducts":"true","productCount":"one","checkMarkMargin":"0 12px 0 4px","reverseDirection":false,"primaryProductBadge":"hide","selectedBorderWidth":"2px","showProductCheckMark":"hide","tertiaryProductBadge":"hide","secondaryProductBadge":"hide","selectedCheckBoxImage":"https://static.superwallassets.com/uoQsDwmrnamiqkfkzRKvC","unselectedCheckBoxImage":"https://static.superwallassets.com/ElRGbHkiRQTvFQ3Gojbfu"}}],"settings":{"containerRadius":"24px","cardBackgroundBlur":true}}],"pageSettings":{"nav":"show","pjs":"https://cdn.superwall.me/runtime/entrypoint.js","font":"","footer":"compact","logoURL":"../public/assets/logo.svg","navLeft":"hide","spacing":"10px","customJS":"let restoreButton = document.querySelector('[data-pw-var=\\\"Div __sw-zpjldarejzcn-9mgugwbj\\\"]');\\nlet swFooterOuterContainer = document.querySelector('#swFooterOuterContainer');\\nswFooterOuterContainer.appendChild(restoreButton);\\n\\nconst primaryButton = document.querySelector('[data-pw-var=\\\"Div __sw-zig-5l9seb8kpgadw7bij\\\"]');\\nconst secondaryButton = document.querySelector('[data-pw-var=\\\"Div __sw-3aeplzh0xxvuk0mcuj2mv\\\"]');\\nconst tertiaryButton = document.querySelector('[data-pw-var=\\\"Div __sw-eemdkqxnkklno-qmwe9bj\\\"]');\\n\\n// When either of the above buttons are clicked, temporarily reduce their size by .1 points\\n\\nprimaryButton.addEventListener('click', () => {\\n    primaryButton.style.transform = 'scale(0.9)';\\n    setTimeout(() => {\\n        primaryButton.style.transform = 'scale(1)';\\n    }, 100);\\n});\\n\\nsecondaryButton.addEventListener('click', () => {\\n    secondaryButton.style.transform = 'scale(0.9)';\\n    setTimeout(() => {\\n        secondaryButton.style.transform = 'scale(1)';\\n    }, 100);\\n});\\n\\ntertiaryButton.addEventListener('click', () => {\\n    tertiaryButton.style.transform = 'scale(0.9)';\\n    setTimeout(() => {\\n        tertiaryButton.style.transform = 'scale(1)';\\n    }, 100);\\n});\\n\\nconst anchorScroll = document.querySelector('[data-pw-var=\\\"Div __sw-bus0t4-o-fj5po1fl9vkj\\\"]');\\nconst allPlansButton = document.querySelector('[data-pw-var=\\\"Text __sw-spi99f-jex79olctcdtld\\\"]');\\n\\n// When you click on the allPlansButton, scroll to the anchorScroll\\nallPlansButton.addEventListener('click', () => {\\n    anchorScroll.scrollIntoView();\\n    }\\n);","fontSize":"calc(min(4.5vw, 1rem))","navRight":"icon","customCSS":".sw-h-divider {\\n  display: none;\\n}\\n\\n.sw-purchase-button {\\n    background: #00D096 !important;\\n}\\n.sw-product-inner-container {\\n    background: white !important;\\n}\\n.sw-dark-overlay {\\n    width: 200vw;\\n    left: -50vw;\\n}\\n\\n[data-pw-var=\\\"Div __sw-zig-5l9seb8kpgadw7bij\\\"] {\\n  transition: transform .1s;\\n}\\n\\n[data-pw-var=\\\"Div __sw-3aeplzh0xxvuk0mcuj2mv\\\"] {\\n  transition: transform .1s;\\n}\\n\\n[data-pw-var=\\\"Div __sw-eemdkqxnkklno-qmwe9bj\\\"] {\\n  transition: transform .1s;\\n}\\n\\n[data-pw-var=\\\"ImageBase __sw-jowhuuamkeaz22mrxolrk\\\"] {\\n  object-fit: contain;\\n}\\n\\n.main-heading {\\n  color: #000;\\n  font-family: Inter;\\n  font-size: 25px;\\n  font-style: normal;\\n  font-weight: 400;\\n  line-height: 100%; /* 25px */\\n  letter-spacing: -0.5px;\\n  text-transform: capitalize;\\n}\\n\\n.accent-heading {\\n  color: #4481FD;\\n  font-family: Inter;\\n  font-size: 30px;\\n  font-style: normal;\\n  font-weight: 700;\\n  line-height: 100%;\\n  letter-spacing: -0.6px;\\n  text-transform: capitalize;\\n}","direction":"vertical","navCenter":"hide","brandColor":"hsla(220, 98%, 63%, 1)","logoHeight":"35px","badgeRadius":"8px","borderColor":"rgba(255, 255, 255, 1)","borderWidth":"0px","cardPadding":"calc(var(--sw-spacing) * 1.6)","googleFonts":"","headingFont":"","navPosition":"fixed","hideProducts":"true","productCount":"one","footerDivider":"hide","forceDarkMode":"false","productRadius":"12px","brandTextColor":"#FFFFFF","contentPadding":"calc(var(--sw-spacing) * 1.6)","footerPosition":"inline","navLeftIconURL":"../public/assets/nav-button.svg","productDivider":"show","productPadding":"15px","purchaseRadius":"15px","useCustomFonts":"false","backgroundColor":"rgba(19, 20, 23, 0.7)","checkMarkMargin":"0 12px 0 4px","containerRadius":"24px","footerAlignment":"center","foregroundColor":"hsla(220, 41%, 25%, 1)","minNavbarHeight":"64px","navRightIconURL":"../public/assets/nav-button.svg","paywallMaxWidth":"500px","previewDarkMode":"false","sectionPaddingX":"0px","sectionPaddingY":"0px","contentAlignment":"top","insetsTopContent":"false","reverseDirection":"false","statusBarPadding":"34px","navBackgroundBlur":"false","cardBackgroundBlur":"true","navBackgroundColor":"auto","navButtonIconsSize":"42px","productDescription":"show","brandSecondaryColor":"","navLeftInnerIconURL":"../public/assets/nav-button.svg","primaryProductBadge":"hide","selectedBorderWidth":"2px","navRightInnerIconURL":"../public/assets/nav-button.svg","showProductCheckMark":"hide","tertiaryProductBadge":"hide","buttonBackgroundColor":"","purchaseButtonLineTwo":"show","secondaryProductBadge":"hide","selectedCheckBoxImage":"https://static.superwallassets.com/uoQsDwmrnamiqkfkzRKvC","paywallBackgroundColor":"hsla(210, 100%, 98%, 1)","productBackgroundColor":"rgba(0,0,0,0.85)","hideFixedPurchaseDrawer":"true","unselectedCheckBoxImage":"https://static.superwallassets.com/ElRGbHkiRQTvFQ3Gojbfu","backgroundContentMaxWidth":"paywallMaxWidth","autoAdjustContentAlignment":"true"},"backgroundContent":[]}`))
        }
        /* __SUPERWALL_REPLACE_END___ */

        const configure = (options, darkOptions) => {
          // constants and variables
          const isEditor = window.self !== window.top
          let documentRoot = document.documentElement;
          let purchaseGroupContainer = document.getElementById('swPurchaseGroupContainer')
          let paywallContainer = document.getElementById('contentContainer')

          var dSettings = {}

          if (options) {
            dSettings = options
          }

          // default inputs
          var settings = {
            autoAdjustContentAlignment: "true", // true, false
            backgroundColor: "rgba(19, 20, 23, 0.7)",
            badgeRadius: "8px",
            borderColor: "rgb(70,70,70)",
            borderWidth: "1px",
            brandColor: "#4E71FF",
            brandSecondaryColor: "",
            brandTextColor: "#FFFFFF",
            buttonBackgroundColor: "",
            cardBackgroundBlur: "true", // true, false
            cardPadding: "calc(var(--sw-spacing) * 1.6)",
            containerRadius: "25px",
            contentAlignment: "top", // top, bottom, center
            contentPadding: "calc(var(--sw-spacing) * 1.6)",
            direction: "vertical", // vertical, horizontal
            font: "",
            fontSize: "calc(min(4.5vw, 1rem))",
            footer: "normal", // show, hide, compact
            footerAlignment: "spread", // spread, center
            footerDivider: "hide", // show, hide
            footerPosition: "fixed", // true, false
            forceDarkMode: "false",
            foregroundColor: "#FFFFFF",
            googleFonts: "",
            headingFont: "",
            hideProducts: "auto", // true, false, auto
            insetsTopContent: "true", // true, false (ADDED)
            logoHeight: "35px",
            logoURL: "../public/assets/logo.svg",
            minNavbarHeight: "64px",
            nav: "show", // hide, show
            navBackgroundBlur: "true", // true, false
            navBackgroundColor: "auto", // auto or a color
            navButtonIconsSize: "42px",
            navCenter: "show", // hide, mixed, text, image
            navLeft: "mixed", // hide, mixed, text, icon, doubleIcon, doubleText, all
            navLeftIconURL: "../public/assets/nav-button.svg",
            navLeftInnerIconURL: "../public/assets/nav-button.svg",
            navPosition: "fixed", // true, false
            navRight: "mixed", // hide, mixed, text, icon, doubleIcon, doubleText, all
            navRightIconURL: "../public/assets/nav-button.svg",
            navRightInnerIconURL: "../public/assets/nav-button.svg",
            paywallBackgroundColor: "#292929",
            paywallMaxWidth: "480px",
            pjs: "https://cdn.superwall.me/runtime/entrypoint.js",
            previewDarkMode: "false",
            primaryProductBadge: "show", // show, hide
            productBackgroundColor: "rgba(0,0,0,0.85)",
            productCount: "auto", // auto, one, two, three
            productDescription: "show", // show, hide
            productDivider: "hide", // show, hide
            productPadding: "15px",
            productRadius: "12px",
            purchaseRadius: "15px",
            reverseDirection: "false", // true, false
            secondaryProductBadge: "hide", // show, hide
            selectedBorderWidth: "2px",
            spacing: "10px",
            statusBarPadding: "34px",
            tertiaryProductBadge: "hide", // show, hide
            ...dSettings
          }

          const defaultBodyFont = settings.useCustomFonts === "true" ? settings.customBodyFont : settings.font
          const defaultHeadingFont = settings.useCustomFonts === "true" ? settings.customHeadingFont : settings
            .headingFont

          // set fallback fonts
          settings.font =
            `${defaultBodyFont ? `${defaultBodyFont}, ` : ""} system-ui, -apple-system, BlinkMacSystemFont, 'Segoe UI', Roboto, Oxygen, Ubuntu, Cantarell, 'Open Sans', 'Helvetica Neue', sans-serif`
          settings.headingFont =
            `${defaultHeadingFont ? `${defaultHeadingFont}, ` : ""} system-ui, -apple-system, BlinkMacSystemFont, 'Segoe UI', Roboto, Oxygen, Ubuntu, Cantarell, 'Open Sans', 'Helvetica Neue', sans-serif`

          let isIOS = (/iPad|iPhone|iPod/.test(navigator.platform) || (navigator.platform === 'MacIntel' && navigator
            .maxTouchPoints > 1)) && !window.MSStream

          if (isIOS) {
            if ((window.matchMedia && window.matchMedia('(prefers-color-scheme: dark)').matches) || settings
              .forceDarkMode == "true") {
              settings = {
                ...settings,
                ...darkOptions
              }
            }
          } else {
            if (settings.forceDarkMode == "true" || settings.previewDarkMode == "true") {
              settings = {
                ...settings,
                ...darkOptions
              }
            }
          }

          if (!settings.buttonBackgroundColor) {
            settings.buttonBackgroundColor = settings.backgroundColor
          }

          console.log("[SW settings]", settings)

          if (settings.googleFonts != '' && settings.useCustomFonts !== "true") {
            const allFonts = settings.googleFonts.split(',').map(el => el.trim()).filter(el => el != '')
            // unique fonts, without using a Set
            const fonts = allFonts.filter((el, i) => allFonts.indexOf(el) === i)
            console.log("[sw font] google fonts...", fonts)
            console.log("[sw font] google fonts...", settings.font)
            console.log("[sw font] google fonts...", settings.headingFont)
            WebFontConfig = {
              google: {
                families: fonts
              }
            }
            const d = document
            var wf = d.createElement('script'), s = d.scripts[0];
            wf.src = 'https://ajax.googleapis.com/ajax/libs/webfont/1.6.26/webfont.js';
            wf.async = true;
            s.parentNode.insertBefore(wf, s);
          }

          // define css variables
          const cssVars = {
            productRadius: "--sw-product-radius",
            purchaseRadius: "--sw-purchase-radius",
            borderWidth: "--sw-border-width",
            selectedBorderWidth: "--sw-selected-border-width",
            spacing: "--sw-spacing",
            productPadding: "--sw-product-padding",
            fontSize: "--sw-font-size",
            containerRadius: "--sw-container-radius",
            badgeRadius: "--sw-badge-radius",
            font: "--sw-font",
            headingFont: "--sw-heading-font",
            foregroundColor: "--sw-foreground-color",
            backgroundColor: "--sw-background-color",
            brandColor: "--sw-brand-color",
            borderColor: "--sw-border-color",
            brandTextColor: "--sw-brand-text-color",
            buttonBackgroundColor: "--sw-button-bg-color",
            buttonForegroundColor: "--sw-button-fg-color",
            productBackgroundColor: "--sw-product-background-color",
            paywallBackgroundColor: "--sw-paywall-background-color",
            statusBarPadding: "--sw-status-bar-padding",
            paywallMaxWidth: "--sw-paywall-max-width",
            minNavbarHeight: "--sw-min-nav-height",
            logoHeight: "--sw-logo-height",
            navButtonIconsSize: "--sw-nav-buttons-icons-size",
            contentPadding: "--sw-content-padding",
            cardPadding: "--sw-card-padding",
            navBackgroundColor: "--sw-nav-background-color",
            brandSecondaryColor: "--sw-brand-secondary-color"
          }

          // set styling

          Object.entries(cssVars).forEach((e) => {
            const key = e[0]
            const cssName = e[1]
            documentRoot.style.setProperty(cssName, settings[key]);

            if (cssName.endsWith('-color')) {
              const newDiv = document.createElement("div");
              newDiv.style.setProperty('color', settings[key])
              documentRoot.appendChild(newDiv)
              var rgba = window.getComputedStyle(newDiv).getPropertyValue('color').replace('rgba(', '').replace(
                'rgb(', '').replace(')', '').split(', ').map(el => parseFloat(el))
              if (rgba.length == 3) {
                rgba.push(1.0)
              }
              newDiv.remove()
              let alphas = [7, 10, 20, 30, 40, 50, 60, 70, 80, 90, 100]
              alphas.forEach((el) => {
                let newAlpha = Math.round((rgba[3] * el / 100) * 100) / 100
                let newCssName = `${cssName}-${el}`
                let newColor = `rgba(${rgba[0]},${rgba[1]},${rgba[2]},${newAlpha})`
                documentRoot.style.setProperty(newCssName, newColor);
              })
              if (key == 'paywallBackgroundColor' && rgba.length >= 3) {
                try {
                  window.Superwall.paywallBackgroundColor = "#" + ((1 << 24) + (rgba[0] << 16) + (rgba[1] << 8) +
                    rgba[2]).toString(16).slice(1);
                } catch {
                  window.Superwall.paywallBackgroundColor = "#000000"
                }
              }
            }
          })


          // print settings

          // logic to handle switching products
          window.Superwall.selectProduct = (product) => {
            const primaryProductElement = document.getElementById('sw_input_1')
            const secondaryProductElement = document.getElementById('sw_input_2')
            const tertiaryProductElement = document.getElementById('sw_input_3')

            if (product == "primary") {
              primaryProductElement.checked = true
              secondaryProductElement.checked = false
              tertiaryProductElement.checked = false
            } else if (product == "secondary") {
              primaryProductElement.checked = false
              secondaryProductElement.checked = true
              tertiaryProductElement.checked = false
            } else {
              primaryProductElement.checked = false
              secondaryProductElement.checked = false
              tertiaryProductElement.checked = true
            }
          }

          // logic to update bottom padding of paywall container
          if (window.Superwall.updatePaywallContainerPadding === null) {
            // logic to update bottom padding of paywall container
            window.Superwall.updatePaywallContainerPadding = () => {

              documentRoot.style.setProperty('--sw-container-padding', ' calc(var(--sw-spacing) * 1.6)')
              documentRoot.style.setProperty('--sw-content-padding', ' calc(var(--sw-spacing) * 1.6)')
              documentRoot.style.setProperty('--sw-card-padding', ' calc(var(--sw-spacing) * 1.6)')

              const windowWidth = documentRoot.clientWidth
              const windowHeight = documentRoot.clientHeight
              const offset = windowWidth > 544 ? 25 : 0
              documentRoot.style.setProperty('--sw-container-width', `${paywallContainer.clientWidth}px`)

              // adjust for notch on large devices
              if (settings.statusBarPadding == "auto") {
                if (!isEditor) {
                  if (windowHeight > 770) {
                    documentRoot.style.setProperty('--sw-status-bar-padding', "34px");
                  } else {
                    documentRoot.style.setProperty('--sw-status-bar-padding', "0px");
                  }
                  if ((screen.height - window.innerHeight > 10 && isIOS) || screen.height > 950) {
                    documentRoot.style.setProperty('--sw-status-bar-padding', "0px");
                  }
                } else {
                  documentRoot.style.setProperty('--sw-status-bar-padding', "34px");
                }
              }

              if (settings.autoAdjustContentAlignment == "true") {
                if (settings.contentAlignment == "bottom" || settings.contentAlignment == "center") {
                  const padding = parseFloat(getComputedStyle(paywallContainer).paddingLeft)
                  var paywallContentHeight = 0
                  var children = paywallContainer.children;
                  for (var i = 0; i < children.length; i++) {
                    var elcs = getComputedStyle(children[i]);
                    paywallContentHeight += parseFloat(children[i].clientHeight) + parseFloat(elcs.paddingBottom) +
                      parseFloat(elcs.paddingTop) + parseFloat(elcs.marginBottom) + parseFloat(elcs.marginTop);
                  }
                }

              }
            }
          }

          window.Superwall.updatePaywallContainerPadding()
          window.Superwall.settings = settings
        };
      </script>
  </div>

  <script>
    window.Superwall.addHotKey = (hotkeys, fn) => {
      hotkeys = hotkeys.split(' ');

      function test(testObj, e) {
        if (testObj.key !== e.key.toLowerCase()) return false;
        for (var key in testObj)
          if (key !== 'key' && testObj[key] !== e[key]) return false;
        return true;
      }
      var tests = hotkeys.map(function (hotkey) {
        var testObj = {
          shiftKey: false,
          ctrlKey: false,
          altKey: false,
          metaKey: false,
          isComposing: false
        },
          keys = hotkey.toLowerCase().split('+');
        for (var i in keys) {
          switch (keys[i]) {
            case 'shift':
            case 'umschalt':
              testObj.shiftKey = true;
              break;
            case 'ctrl':
            case 'strg':
              testObj.ctrlKey = true;
              break;
            case 'alt':
            case 'option':
              testObj.altKey = true;
              break;
            case 'meta':
            case 'win':
            case 'super':
            case 'mod4':
            case 'command':
            case 'propeller':
              testObj.metaKey = true;
              break;
            case 'compose':
              testObj.isComposing = true;
              break;
            default:
              if (keys[i].length !== 1) throw new Error('Unknown key: ' + keys[i].toUpperCase());
              testObj.key = keys[i];
          }
        }
        return test.bind(null, testObj);
      });

      window.addEventListener('keydown', function (e) {
        for (var i in tests)
          if (tests[i](e)) {
            e.hotkey = hotkeys[i];
            fn.call(this, e);
          }
      }, true);

    }

    window.Superwall.templateEditor = () => {
      const location = btoa(window.location.href)
      const url = `../simulator/?ipad=false&minimal=true&ub64=${location}`
      window.open(url, '_blank')
    }

    window.Superwall.simulator = () => {
      const location = btoa(window.location.href)
      const url = `../simulator/?ipad=false&minimal=false&embed=true&ub64=${location}`
      window.open(url, '_blank')
    }

    let isIOS = (/iPad|iPhone|iPod/.test(navigator.platform) || (navigator.platform === 'MacIntel' && navigator
      .maxTouchPoints > 1)) && !window.MSStream
    if (!isIOS && !(window.self !== window.top)) {
      window.Superwall.addHotKey("command+k ctrl+k meta+k", window.Superwall.templateEditor)
      window.Superwall.addHotKey("command+i ctrl+i meta+i", window.Superwall.simulator)
    }
  </script>

  <div id="swHoverIndicator" class="sw-editor-selector-indicator">
    <p id="swHoverVariableName"></p>
  </div>
  <div id="swSelectedIndicator" class="sw-editor-selector-indicator">
    <p id="swSelectedVariableName"></p>
  </div>
  <div id="swHoverEditorIndicator" class="sw-editor-selector-indicator">
  </div>

</body>

</html>
 + """.trimIndent() diff --git a/superwall/src/test/java/com/superwall/sdk/web/WebPaywallRedeemerTest.kt b/superwall/src/test/java/com/superwall/sdk/web/WebPaywallRedeemerTest.kt index 29b33ebd..fb72e3b5 100644 --- a/superwall/src/test/java/com/superwall/sdk/web/WebPaywallRedeemerTest.kt +++ b/superwall/src/test/java/com/superwall/sdk/web/WebPaywallRedeemerTest.kt @@ -39,6 +39,8 @@ import kotlinx.coroutines.test.StandardTestDispatcher import kotlinx.coroutines.test.runTest import org.junit.Before import org.junit.Test +import java.io.FileInputStream +import java.io.FileOutputStream class WebPaywallRedeemerTest { private val context: Context = mockk() @@ -617,8 +619,25 @@ class WebPaywallRedeemerTest { saved = data as Any? } + override fun writeFile( + storable: Storable, + data: String, + ) { + TODO("Not yet implemented") + } + + override fun readFile(storable: Storable): String? { + TODO("Not yet implemented") + } + override fun clean() { } + + override fun getFileStream(storable: Storable): FileOutputStream { + TODO("Not yet implemented") + } + + override fun readFileStream(storable: Storable): FileInputStream = super.readFileStream(storable) } redeemer = WebPaywallRedeemer(