Logo Text Blaze

  • Docs
  • Community
  • Documentation

    Loading...

    Community Forums

    Loading...
Add to Chrome –  It's Free! Go to Dashboard ›

What's on this Page

  • Supported Operators
  • Supported Functions
  • Escaping Special Characters
  • Lists
    • Ordered Lists
    • Keyed Lists
  • List Comprehensions
  • Anonymous Functions
  • Regular Expressions
    • Using simple patterns
    • Using special characters
    • Special characters in regular expressions
REFERENCE

Formula Reference

The Blaze Formula Language makes it possible to use formulas and calculations as part of your snippets. This enables dynamic and conditional snippet content. The Blaze Formula Language is used in the {formula}, {if} and {repeat} commands.

Blaze Formula Language
Count: {formtext: name=count; default=23}

50% More Would Be: {=count * 1.5} {if: count > 10}That's a lot!{else}Not so many.{endif}
_

Supported Operators

The Blaze Formula Language supports many operators for manipulating numbers, comparing values, and working with strings and boolean (yes/no) values.

OperatorDescriptionExample
Mathematical Operators
+Add two numbers together5 + 6 ⇒ 11
-Subtract two numbers7 - 2 ⇒ 5
*Multiply two numbers5 * 2 ⇒ 10
/Divide two numbers9 / 2 ⇒ 4.5
^Take a number to a power2 ^ 3 ⇒ 8
Comparison Operators
==Whether two values are equal (can convert types)2 == 2 ⇒ yes
===Whether two values are strictly equal (will not convert types)2 === "2" ⇒ no
<>Whether two values are not equal (can convert types)2 <> 2 ⇒ no
>=Greater than or equals to5 >= 2 ⇒ yes
>Greater than5 > 2 ⇒ yes
<=Less than or equals to5 <= 2 ⇒ no
<Less than5 < 2 ⇒ no
String Operators
&String concatenation"abc" & "xyz" & 1 ⇒ "abcxyz1"
Logical Operators
notThe opposite of a booleannot no ⇒ yes
andWhether two booleans are both trueyes and no ⇒ no
orWhether either of two booleans is trueyes or no ⇒ yes
ternaryConditional value. Of the form: value1 if condition else value2"big" if 100 > 10 else "small" ⇒ "big"

Text Blaze supports five types of values in formulas:

  • Numbers (e.g. 12, 3.75, or -10)
  • Booleans (yes or no)
  • Text Strings (e.g "abc" or "this is a string")
  • Anonymous functions (e.g. (x) -> x * 2)
  • Lists of values (e.g. [1, 2, "three", yes])

Text Blaze will convert between these when suitable in formulas. If you try to use types a way that is not supported (e.g. 12 + yes or "abc" * 2) an error will be shown.

Supported Functions

Text Blaze supports a variety of functions in formulas.

FunctionDescriptionExample
Mathematical Functions
round(x)Rounds a number to the nearest integerround(1.7) ⇒ 2
floor(x)Rounds a number down to the nearest integerfloor(1.7) ⇒ 1
ceil(x)Rounds a number up to the nearest integerceil(1.2) ⇒ 2
sqrt(x)Gets the square root of a numbersqrt(16) ⇒ 4
abs(x)Gets the absolute value of a numberabs(-3) ⇒ 3
log(x)Gets the base-10 log of a numberlog(100) ⇒ 2
ln(x)Gets the natural log of a numberln(100) ⇒ 4.605
remainder(x, y)Gets the remainder from a divisionremainder(12, 5) ⇒ 2
max(x, y, ...)Gets the maximum of two or more valuesmax(3, 7) ⇒ 7
min(x, y, ...)Gets the minimum of two or more valuesmin(3, 7) ⇒ 3
isodd(x)Whether a number is oddisodd(7) ⇒ yes
iseven(x)Whether a number is eveniseven(7) ⇒ no
random()Gets a random number between 0 and 1random() ⇒ 0.370826324
base(x, base, padding)Express numbers in different numeric bases (e.g. hexadecimal)base(123, 16) ⇒ "7b"
Trigonometric Functions
sin(x)Returns the sine of a number of degreessin(90) ⇒ 1
cos(x)Returns the cosine of a number of degreescos(90) ⇒ 0
tan(x)Returns the tangent of a number of degreestan(45) ⇒ 1
asin(x)Returns the arcsine in degrees of a numberasin(1) ⇒ 90
acos(x)Returns the arccosine in degrees of a numberacos(0) ⇒ 90
atan(x)Returns the arctangent in degrees of a numberatan(1) ⇒ 45
Error Functions
error(msg)Raises a Text Blaze errorerror("Invalid widget size")
catch(x, msg)Evaluates and returns x. If there is an error in x, returns msg. msg may also be an anonymous function taking the error as its first argumentcatch(log(-1), "Negative") ⇒ "Negative"
String Functions
concat(x, y, ...)Concatenates two or more values as a stringconcat("abc", 123) ⇒ "abc123"
lower(x)Lowercase a stringlower("Hi") ⇒ "hi"
upper(x)Uppercase a stringupper("Hi") ⇒ "HI"
proper(x)Capitalizes each wordproper("HI all") ⇒ "Hi All"
trim(x)Removes leading and trailing whitespacetrim(" abc ") ⇒ "abc"
reverse(x)Reverses a stringreverse("abc") ⇒ "cba"
replace(x, find, replacement)Replaces all occurrences of find with replacementreplace("good job", "good", "great") ⇒ "great job"
len(x)The length of a string in characterslen("abc") ⇒ 3
substring(x, start, length)Extracts the portion of the string of length from the start character. If start is negative, it is relative to the end of the string. If length is omitted, the rest of the string is returned.substring("abcdef", 2, 3) ⇒ "bcd"
comparestrings(a, b)Returns a negative number if a is lexicographically before b, a positive number if b is before a and 0 if they are equivalent.comparestrings("at", "dog") ⇒ -1
contains(string, value)Whether one string contains anothercontains("Good morning", "morning") ⇒ yes
startswith(string, value)Whether one string starts with anotherstartswith("Good morning", "morning") ⇒ no
endswith(string, value)Whether one string ends with anotherendswith("Good morning", "morning") ⇒ yes
search(string, value)The position of one string in anothersearch("Good morning", "morning") ⇒ 6
Regular Expression Functions
testregex(x, regex, flags)Tests whether a Regular Expression matches a string. flags is optional and if set to "i", the search will be case-insensitive.testregex("dog", "d..") ⇒ yes
extractregex(x, regex, flags)Extracts the portion of a string matching a Regular Expression. If a capture group is set, extracts the capture group. Flags is optional and if set to "i", the search will be case-insensitive.extractregex("dog", "d(..)") ⇒ "og"
splitregex(x, regex, flags)Splits a string by a regular expressionextractregex("ab5cd3ef", "\d") ⇒ ["ab", "cd", "ef"]
replaceregex(x, regex, replacement, flags)Replaces matches of a regular expression in a string. Flags is optional and if set to "g" will replace all matches.replaceregex("ID: 1234", "\d", "X", "g") ⇒ "ID: XXXX"
List Functions
count(list)The number of elements in a listcount([1, 4, 9]) ⇒ 3
includes(list, value)yes if a list contains a specific valueincludes([1, 4, 9], 4) ⇒ yes
location(list, value)Returns the index or key of the first location of the valuelocation([1, 4, 9], 4) ⇒ 2
merge(list, list2, ...)Merges two or more lists togethermerge([1], [2, 3], [4]) ⇒ [1, 2, 3, 4]
filter(list, fn(value, index/key))Returns a new list comprised of the elements where fn evaluates to yesfilter([1, 4, 9], v -> v > 3) ⇒ [4, 9]
map(list, fn(value, index/key))Returns a new list where each element is replaced with the value of fnmap([1, 4, 9], v -> v > 3) ⇒ [no, yes yes]
reduce(list, accumulator, fn(accumulator, value, index/key))Aggregates the elements of the listreduce([1, 4, 9], 0, (a, v) -> a + v) ⇒ 14
Ordered List Functions
seq(start, end, step)Creates an ordered list from start to end by step. If step is omitted, it defaults to 1 or -1.seq(1, 3) ⇒ [1, 2, 3]
split(str, del)Creates an ordered list by splitting a string by a deliminatorsplit("a/b/c", "/") ⇒ ["a", "b", "c"]
join(list, del)Creates a string by joining the elements of a listjoin([1, 3, 9], "-") ⇒ 1-3-9
sort(list, fn(a, b))Sorts the elements of the ordered list. fn(a, b) will be called for each pair of elements; if is negative, a will be placed before b; if positive, b will be placed before a; if 0, the elements are equivalentsort([3, 9, 1], (a, b) -> a - b) ⇒ [1, 3, 9]
slice(list, start, last)Extract part of the list from start to last. If last is omitted, returns from start to the end of the listslice([1, 4, 9, 16], 2, 3) ⇒ [4, 9]
sum(list)Sum the elements of a listsum([1, 4, 10]) ⇒ 15
average(list)The average (mean) of the elements in a listaverage([1, 4, 10]) ⇒ 5
median(list)The median of the elements in a listmedian([1, 4, 10]) ⇒ 4
find(list, fn)Returns the first element of a list that matches a conditionfind([1, 4, 9], x -> x > 3) ⇒ 4
Keyed List Functions
keys(list)The keys in a keyed list as an ordered listkeys(["a"=123, "b"=345]) ⇒ ["a", "b"]
Miscellaneous Functions
isnumber(x)Whether a value is a numberisnumber("1.2") ⇒ yes
isboolean(x)Whether a value is a booleanisboolean("no") ⇒ yes
islist(x)Whether a value is a listislist([1,2,3]) ⇒ yes
iserror(x)Whether a value is an erroriserror(1 + "a") ⇒ yes
fromjson(str)Converts a JSON string into a listfromjson("{\"a\": [1,2,3]}") ⇒ `["a"=[1, 2, 3]]
urlencode(x)Encodes special characters to allow including a string in a urlurlencode("a&b") ⇒ "a%26b"
urldecode(x)Decodes a urlencoded stringurlencode("a%26b") ⇒ "a&b"
base64encode(x)Base 64 encode a stringbase64encode("hello") ⇒ "aGVsbG8="
base64decode(x)Base 64 decode a stringbase64decode("aGVsbG8=") ⇒ "hello"

Some of Text Blaze's trigonometric function are approximate. Due to the numerical approaches to determine their values there may be extremely small errors in their output (in the 10th decimal place or beyond). For example, instead of equalling exactly 0, cos(90) could instead return 0.00000000000000006123.

Because of this, you may need to round results from these functions when formatting them for output.

Escaping Special Characters

Certain characters have special meaning in Text Blaze commands and strings. For instance, the ; character is used to separate settings in commands. In formula strings, the " character is used to signal the start and end of the string.

To use these special characters in their normal form you can "escape" them by placing a single backslash (\) before them.

For example:

{="this is a \" character"}

will print:

this is a " character

The rules for escaping special characters are slightly different within commands and strings. The following table summarizes these rules:

In CommandsIn Strings
Common escapes: \n, \r, \t, \\Replaced with newline, carriage return, tab, and \ respectively | Replaced with newline, carriage return, tab, and \ respectively
Special characters that need to be escaped{, }, =, ;, and spaces at the start or end of a setting (and within the values of list settings: ,)"
Any other occurrences of \XBackslashes are stripped. E.g. \a\b\c becomes abcBackslashes remain. E.g. \a\b\c stays as \a\b\c

Additional common escapes may be added to Text Blaze in the future, so you should be explicit with your backslashes and not accidentally rely on the behaviors in the third row of this table.

Lists

Lists are special data structures in the sense that they contain other pieces of data. There are two types of lists in Text Blaze: ordered lists and keyed lists.

Ordered Lists

Ordered lists (also called arrays), are a sequential set of zero or more values. Their syntax is as follows:

[Value1, Value2, Value3, ...]

Since there is a distinct order to the elements, you can access a specific element by its index using the syntax list[index]. The first element in the list has index 1, the second index 2 and so on. For example:

Ordered Lists
{=["I'm index 1", 2, 3, "#4"][1]} {=["I'm index 1", 2, 3, "#4"][2]} {=["I'm index 1", 2, 3, "#4"][4]}
_

Ordered lists are especially useful when processing multiple items of some type.

Keyed Lists

Keyed lists are a set of key/value mappings. Their syntax is as follows:

["key a" = ValueA, "key b" = ValueB, ...]

There is no ordering to the keys or values in keyed lists, but you can still access individual elements using the syntax list["key"] or list.key. For example:

Keyed Lists
{=["color"="red", "age"=33, "sign"="libra"]["color"]} {=["color"="red", "age"=33, "sign"="libra"]["age"]}

{=["color"="red", "age"=33, "sign"="libra"].color} {=["color"="red", "age"=33, "sign"="libra"].age}

Note that the "." syntax doesn't work when the key has spaces or other special characters in it. In this case you always need to use the ["key"] approach to reference the value:

{=["color"="red", "age"=33, "sign"="libra", "favorite food"="pizza"]["favorite food"]}
_

Keyed lists are particularly useful when processing data. Keys are case-sensitive.

If the key is not quoted when defining a list, it is a treated as a form variable and the value of the variable is used as the key value. The following example illustrates this:

Form Values as Keys
{k="abc"} {list=[k="My value"]; trim=yes}

{=list["abc"]}
_

List Comprehensions

Text Blaze has powerful methods for manipulating lists: including filter(), map(), and reduce().

Sometimes though, it can be easier to use a powerful Text Blaze feature called list comprehensions if you need to transform a list. List comprehensions carry our an operation across each element of a list.

Imagine you wanted to square each element of an ordered list. The following example shows how to do that with both the map() function and a list comprehension:

Square a List
Numeric List: {formtext: name=n; default=[10, 12, 100, 32, 54]}

Map() version: {=map(n, x -> x^2)}

List comprehension version: {=[x^2 for x in n]}
_

Both work and are almost exactly the same length, but many people find the list comprehension version easier to read.

You can also include an optional if block in your list comprehensions, items will only included when it evaluates to yes. Imagine we only wanted to include items who were larger than 20:

Conditional Square a List
Numeric List: {formtext: name=n; default=[10, 12, 100, 32, 54]}

Filter() & Map() version: {=map(filter(n, x -> x > 20), x -> x^2)}

List comprehension version: {=[x^2 for x in n if x > 20]}
_

List comprehensions can also iterate across keyed lists and can create keyed lists. The following shows the examples of the different possible combinations:

List Comprehensions in Keyed Lists
Ordered List: {formtext: name=o; default=[10, 12, 100]}

Keyed List: {formtext: name=k; default=["a"=10, "b"=12, "c"=100]}

Ordered in and Ordered out: {=[x^2 for x in o]}

Ordered in and Keyed out: {=[index=x^2 for (x, index) in o]}

Keyed in and Ordered out: {=[value^2 for (key, value) in k]}

Keyed in and Keyed out: {=[key=value^2 for (key, value) in k]}
_

Anonymous Functions

An anonymous function is like a regular function except it does not have a name. The syntax for anonymous functions is:

(arg1, arg2, ...) -> doSomething(arg1, arg2, ...)

The parenthesis around the arguments can be omitted if you have exactly one argument:

arg -> doSomething(arg)

Some built-in functions and commands use anonymous functions. For instance, the sort() function for lists takes an anonymous function to define the sorting order to use. The following example shows the use of anonymous functions with the sort() function to sort the same array four different ways:

Sort Example
Numeric Ascending Sort: {=sort([9, 4, 10, 1, 12], (a, b) -> a - b)}

Numeric Descending Sort: {=sort([9, 4, 10, 1, 12], (a, b) -> b - a)}

Alphabetic Ascending Sort: {=sort([9, 4, 10, 1, 12], (a, b) -> comparestrings(a, b))}

Alphabetic Descending Sort: {=sort([9, 4, 10, 1, 12], (a, b) -> -comparestrings(a, b))}
_

Using anonymous functions, you can define whatever sorting method you want.

You can also call anonymous functions directly in your formulas. For example:

Direct Calling Example
{=(x -> x^2)(4)} {=((x, y) -> x + y)(4, 5)}
_

A common use case for anonymous functions is manipulating lists. The filter(), map() and reduce() built-in functions are three functions for operating across a list that leverage anonymous functions.

List Example
Numeric List: {formtext: name=n; default=[10, 12, 100, 32, 54]}

Divide everything in the list by 100: {=map(n, v -> v/100)}

Find the mean of a list: {=reduce(n, 0, (acc, v) -> acc + v)/count(n)}
_

Regular Expressions

A regular expression pattern is composed of simple characters, such as "abc", or a combination of simple and special characters, such as "ab*c" or "Chapter (\d+)\.\d*". The last example includes parentheses which can be used to extract specific parts of the regex using the extractregex() function.

This section is adapted from this MDN Page by Mozilla Contributors and licensed under CC-BY-SA license.

Text Blaze provides the extractregex() and testregex() functions to leverage regular expressions.

Regular Expressions Example
Phone number [format: (XXX) XXX-XXXX]: {formtext: name=number; default=(415) 555-1234}

{if: testregex(number, "^\s*\(\d\d\d\)\s*\d\d\d-\d\d\d\d\s*$")}Area Code: {=extractregex(number, "\((\d\d\d)\)")}{else}That is not a valid phone number.{endif}
_
Regular expressions are a powerful feature of Text Blaze. See the {clipboard} command for examples of how to use them to reference parts of your clipboard.

Using simple patterns

Simple patterns are constructed of characters for which you want to find a direct match. For example, the pattern "abc" matches character combinations in strings only when exactly the characters 'abc' occur together and in that order. Such a match would succeed in the strings "Hi, do you know your abc's?" and "The latest airplane designs evolved from slabcraft." In both cases the match is with the substring 'abc'. There is no match in the string 'Grab crab' because while it contains the substring 'ab c', it does not contain the exact substring 'abc'.

Using special characters

When the search for a match requires something more than a direct match, such as finding one or more b's, or finding white space, the pattern includes special characters. For example, the pattern "ab*c" matches any character combination in which a single 'a' is followed by zero or more 'b's (* means 0 or more occurrences of the preceding item) and then immediately followed by 'c'. In the string "cbbabbbbcdebc," the pattern matches the substring 'abbbbc'.

The table at the end of this section provides a complete list and description of the special characters that can be used in regular expressions.

Special characters in regular expressions

Table of special characters that can be used in regular expressions:

CharacterMeaning
\Matches according to the following rules:

A backslash that precedes a non-special character indicates that the next character is special and is not to be interpreted literally. For example, a 'b' without a preceding '' generally matches lowercase 'b's wherever they occur. But a '\b' by itself doesn't match any character; it forms the special word boundary character.

A backslash that precedes a special character indicates that the next character is not special and should be interpreted literally. For example, the pattern "a*" relies on the special character '\*' to match 0 or more a's. By contrast, the pattern "a\*" removes the specialness of the '*' to enable matches with strings like 'a*'.

To match a \ you need to escape it as \\. If you are entering your regex as a string directly in your snippet, you will need to double escape it (\\\\) as a \\ is replaced by a single \ in Text Blaze quoted strings.
^Matches the beginning of input.

For example, "^A" does not match the 'A' in "an A", but does match the 'A' in "An E".

The '^' has a different meaning when it appears as the first character in a character set pattern. See complemented character sets for details and an example.
$Matches end of input.

For example, "t$" does not match the 't' in "eater", but does match it in "eat".
*Matches the preceding expression 0 or more times. Equivalent to {0,}.

For example, "bo*" matches 'boooo' in "A ghost booooed" and 'b' in "A bird warbled" but nothing in "A goat grunted".
+Matches the preceding expression 1 or more times. Equivalent to {1,}.

For example, "a+" matches the 'a' in "candy" and all the a's in "caaaaaaandy", but nothing in "cndy".
?Matches the preceding expression 0 or 1 time. Equivalent to {0,1}.

For example, "e?le?" matches the 'el' in "angel" and the 'le' in "angle" and also the 'l' in "oslo".

If used immediately after any of the quantifiers *, +, ?, or {}, makes the quantifier non-greedy (matching the fewest possible characters), as opposed to the default, which is greedy (matching as many characters as possible). For example, applying "\d+" to "123abc" matches "123". But applying "\d+?" to that same string matches only the "1".
.(The decimal point) matches any single character except the newline character.

For example, ".n" matches 'an' and 'on' in "nay, an apple is on the tree", but not 'nay'.
x|yMatches 'x', or 'y' (if there is no match for 'x').

For example, "green|red" matches 'green' in "green apple" and 'red' in "red apple." The order of 'x' and 'y' matters. For example "a*|b" matches the empty string in "b", but "b|a*" matches "b" in the same string.
{n}Matches exactly n occurrences of the preceding expression. N must be a positive integer.

For example, "a{2}" doesn't match the 'a' in "candy," but it does match all of the a's in "caandy," and the first two a's in "caaandy."
{n,}Matches at least n occurrences of the preceding expression. N must be a positive integer.

For example, "a{2,}" will match "aa", "aaaa" and "aaaaa" but not "a"
{n,m}Where n and m are positive integers and n <= m. Matches at least n and at most m occurrences of the preceding expression. When m is omitted, it's treated as ∞.

For example, "a{1,3}" matches nothing in "cndy", the 'a' in "candy," the first two a's in "caandy," and the first three a's in "caaaaaaandy". Notice that when matching "caaaaaaandy", the match is "aaa", even though the original string had more a's in it.
[xyz]Character set. This pattern type matches any one of the characters in the brackets, including escape sequences. Special characters like the dot(.) and asterisk (*) are not special inside a character set, so they don't need to be escaped. You can specify a range of characters by using a hyphen, as the following examples illustrate.

The pattern [a-d], which performs the same match as [abcd], matches the 'b' in "brisket" and the 'c' in "city". The patterns "[a-z.]+" and "[\w.]+" match the entire string "test.i.ng".
[^xyz]A negated or complemented character set. That is, it matches anything that is not enclosed in the brackets. You can specify a range of characters by using a hyphen. Everything that works in the normal character set also works here.

For example, [^abc] is the same as [^a-c]. They initially match 'r' in "brisket" and 'h' in "chop."
[\b]Matches a backspace (U+0008). You need to use square brackets if you want to match a literal backspace character. (Not to be confused with \b.)
\bMatches a word boundary. A word boundary matches the position where a word character is not followed or preceded by another word-character. Note that a matched word boundary is not included in the match. In other words, the length of a matched word boundary is zero. (Not to be confused with [\b].)

Examples:
"\bm" matches the 'm' in "moon" ;
"oo\b" does not match the 'oo' in "moon", because 'oo' is followed by 'n' which is a word character;
"oon\b" matches the 'oon' in "moon", because 'oon' is the end of the string, thus not followed by a word character;
"\w\b\w" will never match anything, because a word character can never be followed by both a non-word and a word character.

Note: The regular expression engine defines a specific set of characters to be "word" characters. Any character not in that set is considered a word break. This set of characters is fairly limited: it consists solely of the Roman alphabet in both upper- and lower-case, decimal digits, and the underscore character. Accented characters, such as "é" or "ü" are, unfortunately, treated as word breaks.
\BMatches a non-word boundary. This matches a position where the previous and next character are of the same type: Either both must be words, or both must be non-words. The beginning and end of a string are considered non-words.

For example, "\B.." matches 'oo' in "noonday", and "y\B." matches 'ye' in "possibly yesterday."
\dMatches a digit character. Equivalent to [0-9].

For example, "\d" or "[0-9]" matches '2' in "B2 is the suite number."
\DMatches a non-digit character. Equivalent to [^0-9].

For example, "\D" or "[^0-9]" matches 'B' in "B2 is the suite number."
\sMatches a single white space character, including space, tab, form feed, line feed. For example, "\s\w*" matches ' bar' in "foo bar."
\SMatches a single character other than white space. For example, "\S*" matches 'foo' in "foo bar."
\wMatches any alphanumeric character including the underscore. For example, "\w" matches 'a' in "apple," '5' in "$5.28," and '3' in "3D."
\WMatches any non-word character. For example, "\W" matches '%' in "50%."
  • Guides
    • Quick Start
    • Teams and Organizations
    • Forms
    • Sharing Snippet Folders
    • Autopilot
    • Tidying Whitespace
  • Tutorial Videos 🎬
  • Examples
    • Email
    • Invoice
    • Library Notice
  • Frequently Asked Questions
  • Formula Reference
  • Dynamic Command Reference
    • Using Dynamic Commands
    • formula ({=})
    • {click}
    • {clipboard}
    • {cursor}
    • {error}
    • {formdate}
    • {formmenu}
    • {formparagraph}
    • {formtext}
    • {formtoggle}
    • {if}
    • {import}
    • {key}
    • {link}
    • {note}
    • {repeat}
    • {site}
    • {snippet}
    • {time}
    • {user}
    • {wait}
  • Connected Snippets
    • Overview
    • {image}
    • {urlload}
    • {urlsend}

About

Plans
Text Blaze for Business
Sharing Snippets
Forms
Autopilot
Dynamic Replacements

Support

Contact Us
Documentation
Community Forum
Blog

Other

Privacy Policy
Terms of Service
Open Source Licenses
© 2020 Blaze Today Inc