Gödel numbering of a string Background
Gödel numbers are a way of encoding any string with a unique positive integer, using prime factorisations:
First, each symbol in the alphabet is assigned a predetermined integer code.
Then, to encode a string \$ x_1 x_2 x_3 \ldots x_n \$, where each \$ x_i \$ represents an symbol's integer code, the resultant number is
$$ \prod_{i=1}^n p_i^{x_i} = 2^{x_1} \cdot 3^{x_2} \cdot 5^{x_3} \cdot \ldots \cdot p_n^{x_n} $$
where \$ p_i \$ represents the \$ i \$th prime number. By the fundamental theorem of arithmetic, this is guaranteed to produce a unique representation.
For this challenge, we will only consider strings made of the symbols Gödel originally used for his formulae and use their values, which are:

0: 1
s: 3
¬: 5
∨: 7
∀: 9
(: 11
): 13

...although for simplicity the symbols ¬, ∨, and ∀ can be replaced by the ASCII symbols ~, |, and A respectively.
(I don't know why Gödel used only odd numbers for these, but they're what he assigned so we're sticking with it)
Challenge
Given a string consisting only of the symbols above, output its Gödel encoding as an integer.
You may assume the input will consist only of character in the set 0s~|A().
Example
For the string ~s0:

start with \$ 1 \$, the multiplicative identity
the first character ~ has code \$ 5 \$; the 1st prime is \$ 2 \$, so multiply by \$ 2 ^ 5 \$; the running product is \$ 32 \$
the 2nd character s has code \$ 3 \$; the 2nd prime is \$ 3 \$, so multiply by \$ 3 ^ 3 \$; the running product is \$ 864 \$
the 3rd character 0 has code \$ 1 \$; the 3rd prime is \$ 5 \$, so multiply by \$ 5 ^ 1 \$; the running product is \$ 4320 \$
so the final answer is \$ 4320 \$

Test-cases
Input        Output
&quot;&quot;           1
&quot;A&quot;          512
&quot;~s0&quot;        4320
&quot;0A0&quot;        196830
&quot;)(&quot;         1451188224
&quot;sssss0&quot;     160243083000
&quot;~(~0|~s0)&quot;  42214303957706770300186902604046689348928700000
&quot;0s~|A()&quot;    5816705571109335207673649552794052292778133868750

Rules

Your program does not have to work for strings that would produce larger integers than your programming language can handle, but it must work in theory
You can accept input as a string, list of characters, or list of code-points
You may use any reasonable I/O method
Standard loopholes are forbidden
This is code-golf, so the shortest code in bytes wins
JavaScript (ES7),  75  72 bytes
Expects an array of ASCII codes.
a=&gt;a.map(g=k=&gt;--d-1?g(k,d=n%d?d:++n):p*=n**(17088/k%75%14|1),d=p=n=1)&amp;&amp;p

Try it online!
Magic formula
The formula 17088/k%75%14|1 was found by injecting random values into several handcrafted templates.
More specifically, the template for this one was `${p}/k%${m0}%${m1}|1` with \$0&lt;p&lt;10^5\$, \$0&lt;m_0&lt;10^3\$ and \$12\le m_1 \le 15\$.
 char. |  k  | floor(17088 / k) | mod 75 | mod 14 | OR 1
-------+-----+------------------+--------+--------+------
  '('  |  40 |        427       |   52   |   10   |  11
  ')'  |  41 |        416       |   41   |   13   |  13
  '0'  |  48 |        356       |   56   |    0   |   1
  'A'  |  65 |        262       |   37   |    9   |   9
  's'  | 115 |        148       |   73   |    3   |   3
  '|'  | 124 |        137       |   62   |    6   |   7
  '~'  | 126 |        135       |   60   |    4   |   5

Commented
a =&gt;                // a[] = input
a.map(g = k =&gt;      // for each ASCII code k in a[]:
  --d - 1 ?         //   decrement d; if d is not equal to 1:
    g(              //     do a recursive call to the callback function:
      k,            //       pass k unchanged
      d =           //       update d:
        n % d ? d   //         if d is not a divisor of n, leave d unchanged
              : ++n //         otherwise, increment n and set d = n
    )               //     end of recursive call
  :                 //   else (n is now the next prime):
    p *=            //     multiply p by
      n ** (        //     n raised to the power of
        17088 / k   //     the odd positive integer &lt;= 13 which is obtained
        % 75 % 14   //     by applying our magic formula to k
        | 1         //
      ),            //
  d = p = n = 1     //   start with d = p = n = 1
) &amp;&amp; p              // end of map(); return p