text:
(RGS 2/5) How many strings can you count within these character classes?
Task
Given a string composed of ASCII printable characters, return how many strings could fit the given pattern with character literals and regex-like ranges.
Pattern string
The pattern string follows this grammar (the | means an option and the * means 0 or more occurrences of whatever was immediately to the left):
pattern := '' | pattern_string
pattern_string := (SAFE_CHAR | ASCII_RANGE) pattern_string*
ASCII_RANGE := '[' CHAR '-' CHAR ']'

where CHAR is any ASCII character in the range [32, 127] and SAFE_CHAR is any CHAR except the three characters [, - and ].
Examples
Examples of pattern strings would be a, [0-*]4fj, [a-z][4-9]D[d-B].
Input
The pattern string. You can assume all ranges are well-formed and that all the second characters in the ranges have their ASCII codepoints >= than the corresponding first characters in the range.
Output
The integer corresponding to the number of strings that match the given pattern string.
Test cases
"" -> 1
"a" -> 1
"[*-0]" -> 7
"[0-9][0-9]" -> 100
"[a-z]d[A-z]" -> 1508
"[<->]" -> 3
"[!-&]" -> 6
"[d-z]abf[d-z]fg" -> 529
"[[-]]" -> 3
"[a-a][b-b]cde[---]" -> 1
"[0-1][0-1][0-1][0-1][0-1][0-1][0-1][0-1][0-1][0-1][0-1][0-1]" -> 4096
"[--[][--]]" -> 2303
"[[-[].[]-]]" -> 1

You can check this Python reference implementation that I used to generate the test cases.
This is code-golf so shortest submission in bytes, wins! If you liked this challenge, consider upvoting it... And happy golfing!

This is the second challenge of the RGS Golfing Showdown. If you want to participate in the competition, you have 96 hours to submit your eligible answers. Remember there is still 400 reputation in prizes! (See 6 of the rules)
Also, as per section 4 of the rules in the linked meta post, the "restricted languages" for this second challenge are: 05AB1E, W, Jelly, Japt, Gaia, MathGolf and Stax, so submissions in these languages are not eligible for the final prize. But they can still be posted!!
Otherwise, this is still a regular code-golf challenge, so enjoy!

please don't leave comments consisting of only things like "+1, good answer" -- these are noise and produce clutter when left on almost every solution

@Doorknob ok, sorry for that. It was not my intention to produce clutter!

CP-1610 machine code (Intellivision),  23  22 DECLEs1 ≈ 28 bytes
As per the exception described in this meta answer, the exact score is 27.5 bytes (220 bits)
A routine taking a null-terminated string as an inline argument through R4 and returning the result in R1.
2B9 001     |         MVII    #1,     R1
2A0         | @@read  MVI@    R4,     R0
080         |         TSTR    R0
204 00F     |         BEQ     @@rtn
378 05B     |         CMPI    #'[',   R0
22C 007     |         BNEQ    @@read
2A0         |         MVI@    R4,     R0
00C         |         INCR    R4
320         |         SUB@    R4,     R0
020         |         NEGR    R0
008         |         INCR    R0
004 11C 1DC |         CALL    MULT
091         |         MOVR    R2,     R1
220 012     |         B       @@read
0A7         | @@rtn   JR      R4

A note about subroutine calls
The CP-1610 instruction for calling subroutines is JSR Rx, $address. This instruction saves the return address in Rx instead of pushing it on the stack as many other CPUs do.
This allows to pass a block of arguments that immediately follows the function call. This is a common practice in CP-1610 programming and that's what we use here.
        JSR     R4,     count     ; call to subroutine through R4
        STRING  "[*-0]", 0        ; argument
        ...                       ; we will return here

Obviously, the subroutine is responsible for reading the correct number of arguments and eventually jumping to the expected return address.
Full commented test code
        ROMW    10                ; use 10-bit ROM width
        ORG     $4800             ; map this program at $4800

PNUM    QEQU    $18C5             ; EXEC routine: print a number
MULT    QEQU    $1DDC             ; EXEC routine: signed multiplication

        ;; ------------------------------------------------------------- ;;
        ;;  main code                                                    ;;
        ;; ------------------------------------------------------------- ;;
main    PROC

        SDBD                      ; set up an interrupt service routine
        MVII    #isr,   R0        ; to do some minimal STIC initialization
        MVO     R0,     $100
        SWAP    R0
        MVO     R0,     $101

        EIS                       ; enable interrupts

        MVII    #$200,  R3        ; R3 = backtab pointer

        JSR     R4,     count     ; test cases
        STRING  "", 0
        CALL    print
        JSR     R4,     count
        STRING  "a", 0
        CALL    print
        JSR     R4,     count
        STRING  "[*-0]", 0
        CALL    print
        JSR     R4,     count
        STRING  "[0-9][0-9]", 0
        CALL    print
        JSR     R4,     count
        STRING  "[a-z]d[A-z]", 0
        CALL    print
        JSR     R4,     count
        STRING  "[<->]", 0
        CALL    print
        JSR     R4,     count
        STRING  "[!-&]", 0
        CALL    print
        JSR     R4,     count
        STRING  "[d-z]abf[d-z]fg", 0
        CALL    print
        JSR     R4,     count
        STRING  "[[-]]", 0
        CALL    print
        JSR     R4,     count
        STRING  "[a-a][b-b]cde[---]", 0
        CALL    print
        JSR     R4,     count
        STRING  "[0-1][0-1][0-1][0-1][0-1][0-1][0-1][0-1][0-1][0-1][0-1][0-1]", 0
        CALL    print
        JSR     R4,     count
        STRING  "[--[][--]]", 0
        CALL    print
        JSR     R4,     count
        STRING  "[[-[].[]-]]", 0
        CALL    print

        DECR    R7                ; done: loop forever

        ENDP

        ;; ------------------------------------------------------------- ;;
        ;;  prints the result of a test case                             ;;
        ;; ------------------------------------------------------------- ;;
print   PROC

        PSHR    R5                ; save the return address on the stack

        MOVR    R1,     R0        ; R0 = number to print
        MVII    #4,     R1        ; R1 = number of digits
        MOVR    R3,     R4        ; R4 = backtab pointer
        ADDI    #5,     R3        ; advance by 5 characters for the next one
        PSHR    R3                ; save R3
        CLRR    R3                ; R3 = attributes (black)
        CALL    PNUM              ; invoke the EXEC routine
        PULR    R3                ; restore R3

        PULR    R7                ; return

        ENDP

        ;; ------------------------------------------------------------- ;;
        ;;  ISR                                                          ;;
        ;; ------------------------------------------------------------- ;;
isr     PROC

        MVO     R0,     $0020     ; enable display

        CLRR    R0
        MVO     R0,     $0030     ; no horizontal delay
        MVO     R0,     $0031     ; no vertical delay
        MVO     R0,     $0032     ; no border extension
        MVII    #$D,    R0
        MVO     R0,     $0028     ; light-blue background
        MVO     R0,     $002C     ; light-blue border

        JR      R5                ; return from ISR

        ENDP

        ;; ------------------------------------------------------------- ;;
        ;;  our routine                                                  ;;
        ;; ------------------------------------------------------------- ;;
count   PROC

        MVII    #1,     R1        ; initialize R1 to 1

@@read  MVI@    R4,     R0        ; R0 = current character
        TSTR    R0                ; end of string?
        BEQ     @@rtn             ; if yes, return

        CMPI    #'[',   R0        ; is this a '['?
        BNEQ    @@read            ; if not, just go on with the next character

        MVI@    R4,     R0        ; R0 = ASCII code of the starting character
        INCR    R4                ; skip the '-'
        SUB@    R4,     R0        ; subtract the ASCII code of the ending character
        NEGR    R0                ; negate
        INCR    R0                ; increment
        CALL    MULT              ; compute R2 = R0 * R1
        MOVR    R2,     R1        ; and save the result in R1

        B       @@read            ; go on with the next character

@@rtn   JR      R4                ; return

        ENDP

Output

screenshot from jzIntv

1. A CP-1610 opcode is encoded with a 10-bit value (0x000 to 0x3FF), known as a 'DECLE'.

Haskell, 50 48 bytes
f[]=1
f('[':a:b:c:s)=length[a..c]*f s
f(a:s)=f s

Try it online!

JavaScript (Node.js),  66 65  60 bytes
s=>(s.replace(/\[.../g,s=>r*=([,b]=Buffer(s))[3]-b+1,r=1),r)

Try it online!
Commented
s => (                      // s = input string
  s.replace(                // find in s all occurrences of
    /\[.../g,               // '[' followed by 3 characters
    s =>                    // given the matched string s:
      r *=                  //   multiply r by:
        ([, b] = Buffer(s)) //     the difference between
        [3]                 //     the ASCII code of the 4th character
        - b                 //     and the ASCII code of the 2nd one
        + 1,                //     + 1
      r = 1                 //   start with r = 1
  ),                        // end of replace()
  r                         // return r
)                           //

JavaScript (Node.js),  65  64 bytes
A recursive solution.
f=s=>s?-~([g,b,,c]=Buffer(s),!(g^=91)*(c-b))*f(s.slice(g?1:5)):1

Try it online!
Commented
f = s =>             // f is recursive function taking a string s
  s ?                // if s is not empty:
    -~(              //   add 1 to the result of the multiplication below
      [g, b,, c] =   //     g, b, c = ASCII codes of 1st, 2nd and 4th characters
        Buffer(s),   //
      !(g ^= 91) *   //     true if g is a '[', or false otherwise
      (c - b)        //     multiply it by the width of the ASCII range
    ) *              //   multiply by ...
    f(               //   ... the result of a recursive call
      s.slice(g ? 1  //     discard 1 character if it was not a group
                : 5) //     or 5 if it was
    )                //   end of recursive call
  :                  // else:
    1                //   stop recursion

MATL, 22 21 bytes
1 byte saved thanks to @DeathIncarnate
'\[.-.'XX"@gHKh)dQ]vp

Try it online! Or verify all test cases.
How it works
'\[.-.'    % Push this string, to be used as regexp
XX         % Implicit input. Cell array of substrings that match the regexp
"          % For each
  @g       %   Push current substring
  HKh      %   Push 2, then 4, concatente horizontally: gives [2 4]
  )        %   Index: gives a string of two chars
  d        %   Consecutive difference (of code points)
  Q        %   Add 1
]          % End
v          % Concatenate all stack contents vertically (result may be empty)
p          % Product. Implicit display

Quick 1 byte saving by removing the final ] which is technically unneeded it seems: Try it online!

C (gcc), 58 56 54 52 50 bytes
f(char*s){s=*s?*s++-91?f(s):(s[2]-*s+1)*f(s+4):1;}

Try it online!
Thanks to @S.S. Anne for 2 bytes, and to @Arnauld for 2 more bytes!
This is a recursive solution in C.

54 bytes

Thanks, @S.S.Anne -- I've removed those unnecessary parentheses.

52 bytes

Thanks, @Arnauld -- nice reworking!

C (gcc), 77 \$\cdots\$ 59 58 bytes
Saved 2 bytes thanks to Kevin Cruijssen!!!
Saved 11 13 bytes thanks to Arnauld!!!
r;f(char*s){for(r=1;*s;)r*=*s++-91?1:1-*s+(s+=3)[-1];s=r;}

Try it online!

73 bytes

@KevinCruijssen Wow! Was just trying to tuck that i+=3 away and you've tuck that and the if statement away too! Thanks! :-)

61 bytes

@Arnauld Very effective use of dereferences, pointer arithmetic and truth values. You're the master - thanks! :-)

This can actually be optimized some more: 59 bytes

@Arnauld Wow! Nice one - thanks! :-)

Nice additional save with the [-1]. :-)

Darn it, you beat me to it! I'm going to mooch off of this and post a Go answer. And a C++ answer!

@S.S.Anne Go for it! (pun intended) :D

@S.S.Anne It's been a hour and the C++ port is so easy I went for it! :-)

Almost 54 bytes but fails on 2303.

@S.S.Anne Yes, I tried something like that where you only bump to the ']'. That test case was put in to make that (rightly) fail. :-(

05AB1E, 31 21 20 19 bytes
ü5ε2ι`Çs…[-]Q*ÆÄ>}P

-10 bytes thanks to an alternative approach suggested by @ExpiredData.
-2 bytes and a bugfix for [[-[].[]-]] thanks to @Grimmy.
Try it online or verify all test cases.
Explanation:
ü5          # Push all substrings of length 5 of the (implicit) input-string
  ε         # Map each substring abcde to:
   2ι       #  Uninterleave it into 2 blocks: [ace, bd]
     `      #  Push both strings separated to the stack
      Ç     #  Convert the top (bd) to a list of ASCII codepoint integers [B,D]
   s        #  Swap to get the other string (ace) at the top again
    …[-]Q   #  Check if it's equal to "[-]" (1 if truthy; 0 if falsey)
         *  #  Multiply the codepoints by that ([B,D] if truthy; [0,0] if falsey)
   ÆÄ       #  Take the absolute difference between those two (D-B if truthy; 0 if falsey)
     >      #  And increase this by 1
  }P        # After the map: take the product (which will of course be 1 for empty lists)
            # (after which this is output implicitly as result)

Don't we want to Œ5ù find the substrings of length 5, then filter them to be [...] (maybe something shorter but ʒ40SRè„[]SQ} then take odd indices and delta push 1 then product? Seems like that might end up shorter but I keep writing really long bits to it at the moment

Œ5ù => ü5 for -1.

@Grimmy Ah yeah, the undocumented feature. Forgot about that one, thanks! :)

Let me know when you fixed your answer for your new test case! :D

17 (:

@RGS Not the answerer, but the code now correctly handles all test cases

Python 3, 77 75 73 bytes
f=lambda s:s==''or'['!=s[0]and f(s[1:])or(ord(s[3])-ord(s[1])+1)*f(s[5:])

Try it online!
-2 bytes thanks to @Arnauld
-2 bytes thanks to @KevinCruijssen

75 bytes (returns True instead of 1 but it quacks like a 1)

73 bytes by removing the parenthesis and reversing the s[0]!='[' to '['!=s[0].

brainfuck, 134 125 119 bytes
-[+[+<]>>+]<+++<+>>>,>+<[<<[->+>-<<]>>[[+]<<<[->+<]>>>>-]>[>,<,,>[-<->]<+<<<<[->>>>[-<+<<+>>>]<[->+<]<<<]>>>>>]+<,]<<<.

A commented version can be found below. Saved 9 bytes thanks to @S.S.Anne.
You can try it online, where you can check the "memory dump" to see that the final output is the correct result. In practice only works for tests where final result is <= 255.
You are welcome to golf my code, just keep it commented please. Then use this Python script on TIO to do the byte count and remove comments.
Init a cell with 91
-[+[+<]>>+]<+++
<+>>>,>+<
Mem: accumulator = 1 | left bracket = 91 | 0 | ^input char | 1 | 0
[ If something was read
Subtract the 91 from this char
<<[->+>-<<]
>>
Mem: accumulator | 0 | 91 | ^input minus 91 | 1 | 0
Use non destructive flow control to check if the input char was the beginning of a range
[ If the ascii code point was not 91 then this is a safe character
Zero out the input char
[+]
Move the acc to the right
<<<[->+<]>>>
Remove the else flag
>-] (end if)
>
[ Else the character starts a range and layout is
Mem: acc | 0 | 91 | 0 | ^1 | 0
>,<,,
Mem: acc | 0 | 91 | 0 | ^right char | left char
Subtract the two and add one
>[-<->]<+
Mem: acc | 0 | 91 | 0 | ^diff plus one | 0
                    A   B                C
Multiply the accumulator by the diff plus one
The diff plus one will be juggled around A and B
<<<<[ While the acc is still nonzero
->>>>
[-<+<<+>>>]
<[->+<]
<<<
] (end while)
Mem: ^0 | acc | 91 | 0 | diff plus one | 0
>>>>>
] (end else)
Mem: 0 | acc | 91 | 0 | ? | ^0 | 0
Reset workplace
+<
, Try reading again
Mem: acc | 91 | 0 | ^input char | 1 | 0
]
<<<.

Replace ++++++++++[->+++++++++<]+>+ with -[+[+<]>>+]<+++ and you get a solid 122. Can't figure out the dump memory so no The Brainfuck link. Also, you can put your comments in a loop if they're after another loop or if it's the beginning of the program, just make sure to keep your brackets balanced.

BBC BASIC V, 92 bytes
DEFFNf(X$):O=1:FORI=1TOLEN(X$):IFMID$(X$,I,1)="["THENO=O*(1+ASC(MID$(X$,I+3,1))-ASC(MID$(X$,I+1,1))):I=I+5
NEXT:=O

Defines a function that takes a single string argument and returns an integer. Note BBC BASIC V (as implemented on the Acorn Archimedes and RISC PC) was a tokenised language, so commands like MID$ are a single byte. Unfortunately I can't find an online implementation of this, but RPCEmu can be used to test this.

SNOBOL4 (CSNOBOL4), 138 133 bytes
	I =INPUT
	P =1
	A =&ALPHABET
	L =LEN(1)
N	I '[' L . X L L . Y REM . I	:F(O)
	A X @S
	A Y @E
	P =P * (E - S + 1)	:(N)
O	OUTPUT =P
END

Try it online!

@RGS the manual and tutorial found by following the SNOBOL link in the header! There was an answer chaining question a few years back (One OEIS after another) where I learned just enough to submit an answer, and I just kinda kept using it cuz it's so weird. String matching is SNOBOL's main focus, but it is not exactly easy to golf in.

Husk, 22 bytes
ΠmöLu…Ċ2mtf·=Ċ"[-]"2X5

Try it online!
How?
ΠmöLu…Ċ2mtf·=Ċ"[-]"2X5 - string S
                    X5 - sublists of length five
          f            - filter by predicate:
           ·           -   compose two functions:
             Ċ     2   -     2-gaps (every 2nd element) (e.g. "[a-e]" -> "[-]")
            = "[-]"    -     equal to "[-]"?
        m              - map with:
         t             -   tail (e.g. "[a-e]" -> "a-e]")
 m                     - map with:
  ö                    -   compose four functions:
      Ċ2               -     2-gaps (every 2nd element) (e.g. "a-e]" -> "ae")
     …                 -     fill (e.g. "ae" -> "abcde" -- Note: "xx" -> "xx")
    u                  -     remove duplicates (e.g. "xx" -> "x")
   L                   -     length
Π                      - product

Shakespeare Programming Language, 493 398 bytes
-2 bytes thanks to Jonathan Allan
-87 bytes (!) thanks to Jo King
,.Ajax,.Ford,.Act I:.Scene I:.[Enter Ajax and Ford]Ajax:You cat.Scene V:.Ajax:Is I as big as the sum ofThe cube ofa big big cat the cube ofThe sum ofA big cat a cat?If notLet usScene X.Remember you.Open mind.Ford:Open mind.Open mind.You is the sum ofA cat the difference betweenYou I.Ajax:Recall.You is the product ofyou I.Scene X:.Ford:Open mind.Ajax:Is I worse zero?If notLet usScene V.Open heart

Try it online!
Ford is initialized as 1. Ajax reads through the input. When he encounters a [, Ford reads the next and Ajax the third next character, and Ford is multiplied by the difference + 1. When Ajax reaches the end of the input, Ford opens his heart, printing his value.
The shortest representation I found of 91 (the ASCII code of [) is \$91=(2\times2)^3+(2+1)^3\$ but there might be something better.
With spaces and comments:
,.Ajax,.Ford,.                                         A = F = 0
Act I:.Scene I:.
[Enter Ajax and Ford]
Ajax: You is a cat.                                    F = 1
Scene V:.
Ajax: Is I as big as the sum of                        if not(A == 91) (with 91=64+27)
The cube of a big big cat                              (2*2)^3 (=64)
the cube of The sum of A big cat a cat?                (2+1)^3 (=27)
If not Let us Scene X.                                 go to Scene X
Remember you.                                          F[2] = F
Open mind.                                             F = stdin
Ford: Open mind. Open mind.                            A = stdin
You is the sum of A cat the difference between You I.  A = 1 + A -F
Ajax: Recall.                                          F = F[2]
You is the product of you I.                           F = F * A
Scene X:.
Ford: Open mind.                                       A = stdin
Ajax: Is I worse zero? If not Let us Scene V.          if not(A<0) go to Scene V
Open heart                                             print(F)

"The cube ofTwice a big cat" -> "The cube ofa big old cat" saves two

@JonathanAllan Thanks!

441 bytes with a little rearranging. I think it would also be a lot shorter to use Ford's memory instead of a third character

Implementing my suggestion takes it down to 404 bytes

@JoKing Very nice! I had never used a character's memory and assumed it worked differently. Do you want to post this separately?

No no, you can post it. You did most of the legwork anyway

@JoKing Done, thanks! Found 6 more bytes to golf (You is a cat -> You cat, and the final .).

Congratulations on winning the style points for this challenge of the RGS!

@RGS Wow, thanks for the bounty!

Raku, 37 bytes
{[*] map {137+[R-] .ords},m:g/\[.../}

Try it online!

GolfScript, 40 38 36 29 27 bytes
1{\(91={(\(;(@-)}1if@*1$}do

Try it online!
With a bit of teamwork, Grimmy and I have this baby down fairly low. it's a shame my goofy integer trick is no longer here :( Check edits for a neat little GS trick.
1{\(91={(\(;(@-)}1if@*1$}do # Regex Counter
1                           # Our stack is now [str 1]
 {                      }do # Pop the top value after a run. If it's true, loop.
 {\                     }do # Swap the top two element of the stack. [1 str]
 { (91={        }1if    }do # Pop the first char and see if it's "[".
 {     {        }       }do # If so, do the following.
 {     {(\(;(@  }       }do # Get rid of the garbage in our block, leaving just the params
 {     {      - }       }do # Find the difference
 {     {      -)}       }do # Increment
 {               1      }do # If the if statement fails, instead push a 1.
                             # At this point, our stack is [1 str dif] (dif may be 1)
 {                  @   }do # Bring our 1 up. [str dif 1]
 {                   *  }do # Multiply our 1 by dif. [str dif*1]
 {                    1$}do # Duplicate our string. [str dif*1 str]
                             # At this point, if our string is empty, our stack is
                             # ["" dif*1 ""], and we see the output. If it ISN'T
                             # empty, then dif*1 is our new 1, and the next loop
                             # works with this loop's dif instead of with a 1.
                             # This functionally multiplies all the values together.

Got another two by removing the commas! "" is false in GS, so "" times a certain value would still be "".

Gah, beat me to it by three minutes!

27 by using stack manipulation instead of assigning to 1 (too bad, I liked that trick).

aw shucks, what a shame :(

R, 73 bytes
function(s,i=el(gregexpr("\\[.-",s)),u=utf8ToInt(s))prod(u[i+3]-u[i+1]+1)

Try it online!
Today I learned that to include the character [ in a regexp, you need to escape it twice: \\[.

If it is similar to Python, you do \\[ to escape the backslash, so that it then reaches the regex engine as \[. That is why in Python we often see regex strings prefixed with r.

C++ (gcc), 70 bytes
int f(char*s){int r=1;for(;*s;)r*=*s++-91?1:1-*s+(s+=3)[-1];return r;}

Try it online!

Pyth, 21 bytes
*Fmhs.+CMtd:Q"\[.-."1

Try it online!
Standard regex match with :Q"\[.-."1. Then, we remove the leading [ with td and convert to characters with CM.
Next, the clever part: .+ gives deltas between the code points, and s adds up the deltas. This gives just the difference between the first and last characters, ignoring the -.
Finally, h adds one, and *F multiplies everything together.

CJam, 23 bytes
1q{('[={(\(;(@-)@*\}&}h

Try it online!
First time programming in CJam.
1q{('[={(\(;(@-)@*\}&}h
1q                             Push 1, then push the input, stack = [ 1, str ]
  {('[={(\(;(@-)@*\}&}h        Execute this  while the top of the stack is truthy
   ('[=                        Pop the first char and test for equality
                    &          If it is truthy...
       {(\(;(@-)@*\}           Execute this:
        (\(;(@                   Get the two values of the character class to the top of the stack
                                 E.g "0-9]..." -> "9", "0", ...
              -)                 Subtract 2nd element char code by first and increment, stack = [1, str, diff]
                @                Get the 1 to the top of the stack, stack = [ str, 1, diff]
                 *               Multiply top 2 elements, stack = [ str, diff ]
                  \              Swap the top 2, so the string is back on top
  {                  }h        If the string is not empty, run this again. Else print the output

x86-16 machine code, 25 bytes
B3 01       MOV  BL, 1          ; init multiplier
        C_LOOP:
AC          LODSB               ; AL = [SI], SI++
3C 20       CMP  AL, 32         ; is char less than 32
7C 10       JL   DONE           ; if so, exit
3C 5B       CMP  AL, '['        ; is char '['?
75 F7       JNZ  C_LOOP         ; if not, keep looping
AD          LODSW               ; AL = CHR_L
92          XCHG AX, DX         ; DL = CHR_L
AC          LODSB               ; AL = CHR_R
2A C2       SUB  AL, DL         ; AL = CHR_R - CHR_L
98          CBW                 ; AH = 0
40          INC  AX             ; AL = AL + 1
93          XCHG AX, BX         ; AX = multiplier
F7 E3       MUL  BX             ; multiplier *= CHR_R - CHR_L + 1
93          XCHG AX, BX         ; BX = multiplier
EB EA       JMP  C_LOOP         ; keep looping
        DONE:
C3          RET                 ; return to caller

As a callable function, input string in [SI].  Output in BX.
Example test program I/O:

Labyrinth,  53  50 bytes
1 @!{""
}    ;
,:_91-,,;,-
"    ;    `
""";;)~}*{)

Try it online!
How?
Sets the top of the auxiliary stack to 1 and consumes characters from STDIN, if these are [ the next three characters are consumed and the top of the auxiliary stack is multiplied by one more than the difference in ordinals of the relevant two characters. Once the EOF is reached this value is printed.
  1 pop main (0); * 10; + 1 (=1) -> main
  } pop main -> auxiliary  (i.e. set initial cumulative product to 1)
A , read a character, C, ord(C) -> main
    3-neighbours, top of stack is non-zero so turn
  : copy top of main -> main
  _ zero -> main
  9 pop main; * 10; + 9 (=90) -> main
  1 pop main; * 10; + 1 (=91) -> main
  - pop main (a=91); pop main (b=ord(C)); b-a -> main
B   4-neighbours
    if top of main is zero (i.e. we read a '[') then go straight:
  ,   read a character, L, ord(L) -> main  (i.e. L of [L-R])
  ,   read a character, x='-', ord(x) -> main
  ;   pop main (i.e. discard the '-' of [L-R])
  ,   read a character, R, ord(R) -> main  (i.e. R of [L-R])
  -   pop main (a=ord(R)); pop main (b=ord(L)); b-a -> main
  `   pop main; negate -> main
  )   pop main; increment -> main  (i.e. ord(R)-ord(L)+1)
  {   pop auxiliary -> main  (i.e. get current cumulative product)
  *   pop main (a); pop main (b); b*a -> main
  }   pop main -> auxiliary  (i.e. set new cumulative product)
  ~   pop main (0); bitwise NOT (~0=-1) -> main
  )   pop main; increment -> main
      3-neighbours, top of stack is zero so go straight
  ;   pop main (i.e. discard the zero, leaving infinite zeros on main)
  ;   pop main (i.e. discard another zero, sill leaving infinite zeros on main)
  """" no-ops taking us back to the first , instruction at "A"
B   elif top of main is negative (i.e. we read something <'[') then turn left:
  ;   pop main (i.e. discard the result)
  "   no-op
C     3-neighbours
      if top of main (the duplicate of ord(C)) is negative (i.e. EOF) then turn left:
  {     pop auxiliary -> main  (i.e. get cumulative product)
  !     pop main; print as decimal
  @     exit program
C     elif top of main is positive then turn right:
  "     no-op
        we hit a wall so turn around
  "     no-op
        3-neighbours, top of stack is non-zero so turn
  ;     pop main (i.e. discard this leaving infinite zeros on main)
  -     pop main (a=0); pop main (b=0); b-a=0 -> main
        4-neighbours (same location as B but facing down), top of main is zero so go straight
  ;     pop main (i.e. discard one of the infinite zeros off of main)
  )     pop main; increment (=1) -> main
        3-neighbours, top of stack is positive so turn right
  ;     pop main (i.e. discard this 1)
  ;     pop main (i.e. discard one of the infinite zeros off of main)
  """"  no-ops taking us back to the first , instruction at "A"
C     (N.B. elif top of main is zero cannot happen)
B   elif top of main is positive (i.e. we read something >'[') then turn right:
  ;   pop main (i.e. discard the result)
  )   pop main (duplicate of ord(C)); increment -> main
      3-neighbours top of main is positive so turn right:
  ;   pop main (i.e. discard that)
  ;   pop main (i.e. discard one of the infinite zeros off of main)
  """"  no-ops taking us back to the first , instruction at "A"

The complicated 4-neighbour -, along with the dead-end ", is a 3 byte save over the easier to follow:
1
}
,:_91-,,;,-
;    ;    `
""""")~}*{)
     {
    @!

I was very close to awarding the style points to this answer because I always liked labyrinths and I had never seen this language... So good work!

Haskell, 66 64 bytes
Non-regex solution.
f[]=1
f('[':a:b:c:d:s)=(1+(g c)-(g a))*f s
f(a:s)=f s
g=fromEnum

You can try it online! Uses the algorithm in my Python reference implementation.

Burlesque, 29 bytes
"\[.-."~?{)**{3 1}si^p.-+.}mp

Try it online!
"\[.-."~?  # List of all RegEx matches
{
 )**         # Ord()
 {3 1}si     # Select values at indices 3 & 1 (start,end)
 ^p          # Unbox
 .-          # Difference
 +.          # Increment
}mp          # Map product (returns 1 for empty)

Burlesque, 24 bytes
s1r1{@\x01\x7fr\jCB}\m{g1~=}fl

Try it online!
Solution that generates all possible strings and counts the number of matches.
WARNING: May take infinite time and memory.

"WARNING: May take infinite time and memory." is the best kind of code golf warning.

@Mathgeek It's technically shorter...

@DeathIncarnate Does the second program terminate? If it doesn't, it's disqualified by https://codegolf.meta.stackexchange.com/questions/4782/do-programs-have-to-terminate

@EmbodimentofIgnorance Ah darn, not provably. Still fun though.

Invalid answers need to be deleted, not marked "non-competing"

Java 8, 80 76 bytes
r->{int c=1,i=r.length;for(;i-->1;)c*=r[i]==93?r[--i]-r[i-=2]+1:1;return c;}

-4 bytes thanks to @ExpiredData.
Try it online.
Explanation:
r->{               // Method with character-array parameter and integer return-type
  int c=1,         //  Count-integer, starting at 1
      i=r.length;  //  Index integer, starting at the length of the input
  for(;i-->1;)     //  Loop as long as the index is larger than 1,
                   //  and decrease the index every iteration by 1 right after this check
    c*=            //   Multiply the count by:
       r[i]==93?   //    If the `i`'th character of the input is a ']':
        r[--i]     //     Take the `i-1`'th character, by decreasing `i` with 1 first
        -r[i-=2]   //     And decrease it by the `i-3`'th character,
                   //     due to the earlier `--i` and by first decreasing `i` with 2 first
        +1         //     And add 1 to that difference
                   //     (NOTE: We've only decreased `i` by 3 instead of 4 here, but this
                   //      doesn't matter, since it will always be the '[' character of the
                   //      previous block in the next iteration, and thus multiplying by 1
                   //      in the else block)
       :           //    Else (single character match):
        1;         //     Keep the count the same by multiplying with 1
  return c;}       //  And then return this count as result

@RGS It's inspired by both Arnauld's JS and your Haskell answers tbh. My initial approach was generating all n-length permutations of the printable ASCII range and check if it matches the regex, but that approach was ~350 bytes (also because [--]] and [--[] aren't valid regexes in Java), so when I saw Arnauld post his 66 byte solution I quickly dropped it and started over, haha.

76 bytes. it doesn't matter if we skip past characters since it will just multiply by 1

@ExpiredData Ah smart! It will always match the [ of the previous block in that case, so it will guaranteed go to the else and simply keep the count the same by multiplying with 1.

C# (Visual C# Interactive Compiler), 80 76  bytes
r=>{int c=1,i=r.Length;for(;i-->1;)c*=r[i]==93?r[--i]-r[i-=2]+1:1;return c;}

Try it online!
Port of @KevinCruijssen's Java answer

Befunge-98 (PyFunge), 30 bytes
1v;>.@;  <
*>#^~'[-#^_~~$~\1--

Try it online!
Explanation
1v
 >

Push 1 to the stack and move east in the second line
 >.@
#^~

Input character (~), if no input is left print the TOS (.) and quit the execution (@).
'[-#^_

Subtract [ from the input, if the input is [ continue east, otherwise go north.
1v;>.@;  <
 >

Case input ≠ [: Go back to the start of the second line.
*>        ~~$~\1--

Case input = '[': Take the next three characters of input, discard the -, and compute the difference between the two remaining chars, multiply this to the current result.
Animation of the code for input a[0-9]:

Python 3.8 (pre-release), 87 bytes
-5 byte thanks to @SurculoseSputum
lambda s:math.prod(ord(m[3])-ord(m[1])+1for m in re.findall(r'\[.-.',s))
import re,math

Try it online!

-1 byte

-2 bytes by using math.prod instead.

I forgot to remove the redundant square brackets... 87 bytes!

Whitespace, 149 bytes
[S S S T    N
_Push_1][N
S S N
_Create_Label_LOOP][S N
S _Duplicate][S N
S _Duplicate][T N
T   S _Read_STDIN_as_character][T   T   T   _Retrieve_input][S N
S _Dupe][S S S T    S T S N
_Push_10][T S S T   _Subtract][N
T   S S S N
_If_0_Jump_to_Label_DONE][S S S T   S T T   S T T   N
_Push_91][T S S T   _Subtract][N
T   S S N
_If_0_Jump_to_Label_BLOCK_FOUND][N
S N
N
_Jump_to_Label_LOOP][N
S S S N
_Create_Label_BLOCK_FOUND][S N
S _Duplicate][S N
S _Duplicate][T N
T   S _Read_STDIN_as_character][T   T   T   _Retrieve][S N
S _Duplicate][S N
S _Duplicate][S N
S _Duplicate][T N
T   S _Read_STDIN_as_character][T   N
T   S _Read_STDIN_as_character][T   T   T   _Retrieve][S N
T   _Swap_top_two][T    S S T   _Subtract][S S S T  N
_Push_1][T  S S S _Add][T   S S N
_Multiply][S N
S _Duplicate][T N
T   S _Read_STDIN_as_character][N
S N
N
_Jump_to_Label_LOOP][N
S S S S N
_Create_Label_DONE][S N
N
_Discard][T N
S T _Print_as_integer]

Letters S (space), T (tab), and N (new-line) added as highlighting only.
[..._some_action] added as explanation only.
Since Whitespace inputs one character at a time, the input should contain a trailing newline (\n) so it knows when to stop reading characters and the input is done.
Try it online (with raw spaces, tabs and new-lines only).
Explanation in pseudo-code:
Integer count = 1
Start LOOP:
  Integer c = read STDIN as character
  If(c == '\n'):
    Jump to Label DONE
  If(c == '['):
    Jump to Label BLOCK_FOUND
  Go to next iteration of LOOP

Label BLOCK_FOUND:
  Integer a = read STDIN as character
  Read STDIN as character (without saving it)
  Integer b = read STDIN as character
  Integer diff = b - a
  diff = diff + 1
  count = count * diff
  Read STDIN as character (without saving it)
  Go to next iteration of LOOP

Label DONE:
  Print count as integer to STDOUT

@RGS No, I actually program in Whitespace for all my answer. Unless it's a kolmogorov-complexity challenge, in which case I have a partial Java generator I once wrote utilizing this tip of mine. Not directly in TIO though. I use the vii5ard compiler which also has a builtin debugger which works quite well. I can see the values on the stack/heap in the memory tab, and even set breakpoints. But I do actually program like in the top part of my program with the [S S S N\n_Push_0] synthax I came up with myself.

cool, then :) and then you convert your syntax to code?

@RGS Well, converting my synthax to code is easy. I just remove all non-whitespaces with replace("[^ \t\r\n]", "") and that's the code I put in the TIO link. :D

Huh, your replace doesn't support \S?

@Neil It most likely does. xD I could say all other whitespace-types should be removed as well, but I won't use those anyway when writing my answers, so you're right, replace("\S","") should work fine as well. Ah well ¯\(ツ)/¯

Julia 1.0, 62 60 bytes
s->prod(map(x->x[2][1]-x[1][1]+1,eachmatch(r"\[(.)-(.)",s)))

-2 bytes thanks to Robin Ryder
Try it online!

The \] doesn't seem necessary: 60 bytes.

Go, 106 98 bytes
func f(s string)int{r,i:=1,1
for;i<len(s);i++{if s[i-1]==91{r*=1+int(s[i+2]-s[i])
i+=3}}
return r}

-8 bytes thanks to RGS for catching a cleanup that I missed.
Try it online!

98 bytes

@RGS You can tell I wrote this at 6 P.M., can't you?

M, 22 bytes
ṡ5µm2⁼“[-]”ȧOḊm2I‘µ€PḢ

Try it online!
How?
Effectively this is using M as if it were Jelly 4 years ago (except we need the trailing Ḣ as M does not have the same full-program printing as Jelly did or does). Gotta love loopholes :)
ṡ5µm2⁼“[-]”ȧOḊm2I‘µ€PḢ - Link: list of characters
ṡ5                     - all slices of length five
  µ               µ€   - for each:
   m2                  -   modulo two slice ("[a-e]" -> "[-]")
      “[-]”            -   "[-]"
     ⁼                 -   equal?
            O          -   ordinals
           ȧ           -   logical AND
             Ḋ         -   dequeue (N.B. 0Ḋ -> [])
              m2       -   modulo two slice ([97,45,101,93] -> [97,101])
                I      -   deltas           ([97,101] -> [5])
                 ‘     -   increment        ([5] -> [6])
                    P  - product (e.g. [[2],[],[4]] -> [8])
                     Ḣ - head (e.g. [8] -> 8)

So what is exactly the relationship between Jelly and M?

Same author, M is meant to be designed for more mathematical tasks.

Ok, nice loophole exploit :)

But this doesn't beat Jelly anyway...

@a'_' Jelly is in the list of restricted languages. I do, however, expect this to be beaten by other languages that are not (2 so far have).

@RGS - possibly this could come under 4.3 - Dialects. Totally up to you.

Thanks for being understanding. I wanted to allow it, but that would go against the spirit of 4.3... can't you submit an eligible answer in another language..?

My Labyrinth is eligible, but not very terse; I might find something else.

...done with husk - thought it would be shorter, possible it's still golfable.

I did think this didn't look like the M I was used to...

Ruby -n, 45 bytes
x=1;gsub(/\[(.)-(.)/){x*=1+$2.ord-$1.ord};p x

Try it online!

x86 machine code, 30 bytes
Hexdump:
33 d2 f7 f0 8a 11 41 84 d2 75 01 c3 80 fa 5b 75
f3 8a 51 02 2a 11 42 f7 e2 83 c1 04 eb e6

Disassembly:
33 D2                xor         edx,edx
F7 F0                div         eax,eax
again:
8A 11                mov         dl,byte ptr [ecx]   ; load byte
41                   inc         ecx                 ; advance pointer
84 D2                test        dl,dl               ; check for end of string
75 01                jne         cont                ; not end? - continue
C3                   ret                             ; end of string? - return
cont :
80 FA 5B             cmp         dl,5Bh              ; check for ASCII_RANGE
75 F3                jne         again               ; not ASCII_RANGE? - continue
8A 51 02             mov         dl,byte ptr [ecx+2] ;
2A 11                sub         dl,byte ptr [ecx]   ; find range size
42                   inc         edx                 ;
F7 E2                mul         eax,edx             ; eax = eax * size
83 C1 04             add         ecx,4               ; skip the ASCII_RANGE part
EB E6                jmp         again               ; continue

A fastcall function: gets the pointer to the input in ecx and returns the result in eax. A pretty straightforward algorithm, which only uses eax, edx and ecx - no need to save and restore registers!
It initializes eax to 1 and edx to 0 by dividing the 64-bit value edx:eax by eax.

To test this with Visual Studio, use the following C++ test program:
#include <iostream>

int __declspec(naked) __fastcall doit(const char* s)
{
    _asm
    {
        xor edx, edx;
        div eax;
    again:
        mov dl, [ecx];
        inc ecx;
        test dl, dl;
        jne cont;
        ret;
    cont:
        cmp dl, '[';
        jne again;
        mov dl, [ecx + 2];
        sub dl, [ecx];
        inc edx;
        mul edx;
        add ecx, 4;
        jmp again;
    }
}

int main()
{
    std::cout << doit("[d-z]abf[d-z]fg");
}

Charcoal, 31 bytes
≔⪪⮌Ｓ¹θ≔¹ηＷθＦ⁼⊟θ[≧×Ｌ…·⊟θ∧⊟θ⊟θηＩη

Try it online! Link is to verbose version of code. Explanation:
≔⪪⮌Ｓ¹θ

Input the pattern string, reverse it, and split it into individual characters. This allows characters to be consumed within an expression by using Pop(q).
≔¹η

Start off with 1 matching string.
Ｗθ

Repeat until all of the input characters have been processed.
Ｆ⁼⊟θ[

Is this a character range?
≧×Ｌ…·⊟θ∧⊟θ⊟θη

If so then multiply the result by the length of the inclusive range between the next character and the next but three (this saves a byte over converting to ordinals manually). The characters are consumed so that a range that starts or ends at [ does not get misinterpreted as a second range.
Ｉη

Output the result.

Wren, 124 bytes
+10 bytes due to fixing a bug.
Fn.new{|i|i.count<4?1:(i.count..1).map{|x|i[x-1]+i[x-3]+i[x-5]=="]-["?1+i[x-2].bytes[0]-i[x-4].bytes[0]:1}.reduce{|a,b|a*b}}

Try it online!

Your solution currently fails for the test case [[-[].[]-]]! Let me know as soon as you fix it :)

QuadS, 28 bytesSBCS
×/1--/∘⎕UCS¨⍵
\[(.).(.)
\1\2

Try it online!
QuadS is a language based on Dyalog APL's ⎕S (PCRE search operator). Regex operations (2nd and 3rd lines in this case) are written in plain ASCII using PCRE syntax, and post-processing (1st line) can contain arbitrary APL expression.
How it works
×/1--/∘⎕UCS¨⍵  ⍝ Post-processing function
           ¨⍵  ⍝ On each match,
       ⎕UCS    ⍝   Convert to Unicode codepoint and
    -/∘        ⍝   take the difference (e.g. [a-c] -> -2)
  1-           ⍝ 1 minus each of the above
×/             ⍝ Product over all of the above (1 if no matches)
\[(.).(.)  ⍝ PCRE regex to match
\1\2       ⍝ Extract the two significant chars from each match

Pyth, 34 bytes
K1WgJxz\[0=*Kh-C@z+J3C@zhJ=>z+J5;K

Try it online!
I think this is my first Pyth submission.

Retina, 77 74 bytes
L`\[.-.
%/^\[/+/^.(.).\1/(3L$`
$.'$*
3`.
$&$&
)3T`p`_p`.
¶

~`^
.+¶$$.(1$*

Try it online! Link includes test cases. Explanation:
L`\[.-.

List only the ranges themselves (without the close brackets).
%

Process each range separately.
/^\[/+

Repeat while the buffer begins with a [.
/^.(.).\1/(
)

If the second and fourth characters are the same...
3L$`
$.'$*

... then replace that range with its length followed by a *...
3`.
$&$&
3T`p`_p`.

... otherwise duplicate the 3rd character and shift it back by 1 ASCII code point.
¶

Join all of the ranges back together again.
^
.+¶$$.(1$*

Prefix $.(1* to turn the result (if any) into a Retina multiplication, and .+ on its own line to turn that into a substitution command.
~`

Evaluate the result of the substitution command on the previous result, thus performing the multiplication.

Jelly, 18 bytes
ṡ5Œœ€Ḣ“[-]”Ƒ$ƇOI‘P

Try it online!
A full program taking a string and printing an integer.
Thanks to @Grimmy for pointing out a problem with [[-[].[]-]]

This incorrectly outputs -1 for the [[-[].[]-]] test case.

@Grimmy fixed at a cost of 3 bytes

05AB1E, 17 bytes
Port of Mathgeek's GolfScript answer
Δć91QićV¦ćY->ˆ]¯P

Takes input as an array of codepoints. The header code does the conversion.
Δ             ]     # loop until top-of-stack (initially: the input) doesn’t change:
 ć                  #  extract the first character
  91Qi        ]     #  if that character is '[' (ASCII 91):
      ćV            #   extract the first character (range start), store it in Y
        ¦           #   drop the first character ('-')
         ć          #   extract the first character (range end)
          Y-        #   subtract Y
            >       #   add 1
             ˆ      #   append to the global array
               ¯P   # output the product of the global array (1 if empty)

Try it online! or verify all test cases.

Nice one! :) I like the use of the global array. And I need to remember using that "...".V trick for test suites so I won't have to change the ] to }}. :D PS: When you add an explanation, you may want to explicitly mention you take the input as codepoints.

Isn't taking the inputs as codepoints making the problem easier..?

@RGS Well yeah it makes the problem easier, that’s why I do it. (You could ban taking string input as a list of codepoint, but then C and similar languages wouldn’t be able to participate.)

Perl 5 -p, 42 bytes
$\=1;s/\[(.)-(.)]/$\*=1+ord($2)-ord$1/ge}{

Try it online!


text:
Embedding Sets of Sets
Setup: For two sets \$A,B\$, we say \$A \subseteq B\$  if every element in \$A\$ is also in \$B\$.
Another way of saying this, is that we can order the elements of \$A,B\$ into two lists \$L_A,L_B\$, such that \$L_A[i] = L_B[i]\$ where \$i\$ ranges over the indices of \$L_A\$.
We proceed to extend this idea, to define the relation \$\preceq\$. For two sets of sets, \$A,B\$, we say that \$A\preceq B\$ if we can arrange their elements into lists \$L_A,L_B\$, such that \$L_A[i]\subseteq L_B[i]\$ for all indices of \$L_A\$.
Task: Make a program/function which takes two sets of sets, A,B, determines if A ⪯ B as defined in the set up, and then appropriately returns Truthy or Falsy.
Input: You may give A and B to your input as sets. It is up to you how you wish have your function take A and B, be it separately, as a tuple, etc.
If you so choose, or if your language forces your hand, you can enter your input as lists, frozen sets or even submit elements one by one. Likewise, you may choose the datatype to represent the sets inside A and B.
For simplicity's sake, one may assume the elements of the sets in A and B are all integers.
Output: You can define whatever conditions you want to indicate your Truthy and Falsy inputs, as long as these conditions are independent of the output. (e.g. you can say "if my program never halts, this means Falsy")
Examples, with (1,0) indicating (Truthy, Falsy) respectively
A = {{4004,1}}, B = {{4},{4004,1}} => 1
# L_A = [{4004,1}], L_B = [{4004,1},{4}]

A = {{1,2},{5},{8}}, B = {{3,5},{6},{8},{7}} => 0
# {1,2} is not a subset of any set in B

A = {{4,44},{44,444},{4}}, B = {{4,44,444},{4,14},{4,40,44}} => 1
# L_A = [{4,44},{44,444},{4}], L_B = [{4,40,44},{4,44,444},{4,14}]

A = {{1,2,4},{6}}, B = {{1,2},{4},{6}} => 0
# {1,2,4} is not the subset of a single set in B, only the union of B

A = {{1},{1,2},{2}}, B = {{1,3},{2,3},{1,2}} => 1
# L_A = [{1},{1,2},{2}], L_B = [{1,3},{1,2},{2,3}]

A = {{-1},{8},{}}, B = {{-1,8,2},{8,-1,0}} => 0
# There are three elements in A, but only 2 in B, so the last item in L_A will not
# be paired with a superset, even for the empty set, {}. (vacuity be damned)

A = {{-1},{8},{}}, B = {{0,8},{9,-1},{100}} => 1
# L_A = [{-1},{8},{}], B =[{0,8},{9,-1},{100}]

A = {{1,2}{3,4}}, B = {{1,2,3,4},{}} => 0
# {1,2} and {3,4} are each subsets of {1,2,3,4}, and are not subsets of any other
# set in B, thus in the list, one of these will not be paired with their superset

Can we require that the subsets in the input are sorted?

Since you're talking about sets of sets, can I confirm that each input won't have repeated elements?

@xnor yes, you may assume that no elements are repeated.

@Shaggy No. You cannot assume the input is sorted.

Suggest falsy test case: A = {{4004 2} {1}} and B = {{1} {4004 1}}.  My original solution was passing all the current test cases but would have incorrectly returned true for this.

Another suggested falsy test case: A = {{1} {2} {3}} and B = {{1} {1} {1 2 3}}

Python 3, 84 62 58 bytes
Recursive function, A is a list of sets and B is a frozenset; returns false if \$A\preceq B\$ and true otherwise.
f=lambda A,B:A and all(A[0]-b or f(A[1:],B-{b})for b in B)

@PoonLevi and @SurculoseSputum helped save a great amount of bytes.
Explanation:
If A and B satisfy the relationship described, then this recursive statement makes sense:
The first set in A is contained in some i-th element of B and A', B' also satisfy the relationship, where
A' is A without the first set
B' is B without the said i-th element

Because I am returning the reverse, I am actually ensuring that, if the first element of A is contained in some element of B, then A' and B' cannot satisfy the relationship.
Try it online!

Took me a minute to understand why this works. Quite clever

I actually think this may fail some test cases because of how greedily is selects the subset

Nevermind, the any seems to cover that

See the comment I wrote while you were typing that :)

sounds good to me. FYI this is actually an 82 byte solution. You're allowed to put f= \ in the header

with all the test cases - they pass! :-)

62 bytes, with B being a set of frozensets

@PoonLevi wow, I was having problem with set not being hashable, but frozen set solved it! 58 bytes by returning the negated answer.

@PoonLevi didn't know about this -{x} operation :)! Incredible

Two technical points: 1) B needs to be a set (or frozenset) whose elements are itself frozensets; 2) this function returns the empty list when A is empty

@PoonLevi but the empty list is Falsy in Python, so everything is alright. Right?

Yea, that should be fine

Japt -e, 15 13 10 bytes
Vcà mÍdeUn

Try it

Does not handle the empty set correctly. Seems to always return false if you put, [] in A.

I didn't write in the spec but it's in 3rd and 2nd to last test cases. I'll add that into the text of the question in a bit

I think that's right now, @ZacharyHunter.

J, 32 bytes
#@[e.[:#@~.@>@,@{[:<@I.0=#@-.&>/

Try it online!
Left arg is A, right is B.

#@[ Is the len of A?...
e. an element of?...
[:#@~.@>@,@{ any of the lengths, after deduping, of the cartesian product of...
[:<@I. the indexes with value 1 in each row of the matrix defined by...
0= elements that equal zero of...
#@-.&>/ the function table / (like a multiplication table) defined by "the length after set substraction", i.e., whose (i,j) element is the length of the j-th element of B set subtracted from the i-th element of A.

The tio currently outputs ones for all of the test cases.

That’s because they’re all passing.  Each line begins echo <x> = ... where x is the expected outcome for that case

Oh I see! My bad, I mostly know python.

Jelly, 16 bytes
fƑ"Ạ¥ⱮŒ!}Ẹa,LÞƑ¥

Try it online!
A dyadic link taking A as its left argument and B as its right. Returns 1 for true and 0 for false.
Added 6 bytes to more correctly handle the situation when the length of A is more than the length of B. The previous test case worked only because the extra set was empty.
Explanation
    ¥ⱮŒ!}        | Using each permutation of B in turn as the right argument:
fƑ"              | - Check whether A is invariant when filtered pairwise to that permutation of B
   Ạ             | - All true
         Ẹ       | Any true
          a    ¥ | And the following is true for the original arguments:
           ,     | - Pair
            LÞƑ  | - Invariant when sorted by length

Python 3, 110 107 bytes
Simply try to match A with all permutations of B.
Take input as 2 lists of sets, and output False if \$A \preceq B\$, and True otherwise. (Note that the truthiness is reversed).
lambda A,B:len(A)>len(B)or all(any(a-b for a,b in zip(A,P))for P in permutations(B))
from itertools import*

Try it online!

I was writing something similar using all, any and permutations. Got stuck where I needed zip. +1

@Cruncher don't want to be annoying, but you might also like my Python answer that doesn't use explicit permutations :)

JavaScript (ES6),  79  77 bytes
Takes input as (B)(A), where \$B\$ is a list of sets and \$A\$ is a list of lists. Returns a falsy value (false or undefined) if \$A\preceq B\$, or true otherwise.
B=>g=([a,...A],u)=>a&&B.every((b,i)=>u>>i&1|a.some(v=>!b.has(v))|g(A,u|1<<i))

Try it online!

Charcoal, 37 bytes
⊞υＡＦυ«≔⊟ιθ≔⊟ιι¬ιＦιＦθ¿¬⁻κλ⊞υ⟦⁻ι⟦κ⟧⁻θ⟦λ

Try it online! Link is to verbose version of code. Takes input as a list of list of lists and outputs nothing if A is not a subset of B, otherwise the number of ways it found to verify that A is a subset of B as a string of -s (would be +1 byte to output just a single -). Explanation:
⊞υＡＦυ«

Perform a breadth-first search starting with the original input.
≔⊟ιθ≔⊟ιι

Extract the latest pair of sets to check.
¬ι

If A is (now) empty then it is a subset of B.
ＦιＦθ¿¬⁻κλ

Find all pairs of sets in A and B such that one is a subset of the other.
⊞υ⟦⁻ι⟦κ⟧⁻θ⟦λ

For each such pair, add the sets with those elements removed to the search.

Ruby, 60 45 bytes
->a,b{a.all?{|x|b.any?{|y|f[a-[x&y],b-[y]]}}}

Try it online!
How:
Recursively check: for every x in a
->a,b{a.all?{|x|                            }

there is at least a y in b
                b.any?{|y|                }

Such that removing x⋂y from a and y from b, the condition is still valid.
                          f[a-[x&y],b-[y]]

Sorry, what?
A and B are sets of sets. If A is empty, the function returns true. If B is empty and A is not empty, then the function returns false. So far, so good.
Otherwise, let's check what happens if we remove the sets as specified:

if x⊆y then x⋂y==x. We remove x from A and y from B, then check if the remaining sets satisfy the initial condition recursively, until A or B is empty.
if x⊄y but x⋂y is contained in A, we remove it anyway. We will check the same x again on a different y in the next iteration. We need to remove an item from A and B, we are just removing them in a different order, and that won't affect the final result.
if x⊄y and x⋂y is not contained in A, we can continue: x won't be removed in the next iterations, and the check will fail as soon as B is empty.

05AB1E, 11 bytes
Outputs 0 if A⪯B, a positive integer otherwise.
δKøœεÅ/˜g}ß

Try it online!

Julia 1.0, 61 bytes
f(a,b)=a==[]||any(a[1]⊆x&&f(a[2:end],setdiff(b,x)) for x=b)

Try it online!

source: Stack Exchange

license: Creative Commons - Attribution Share-Alike - https://creativecommons.org/licenses/by-sa/4.0/

sort: votes


text:
All roads lead to Rome
"All roads lead to Rome" is a saying that essentially means there are plenty of different ways of achieving an objective.
Task
Your task is to write a program that finds a set of link connections from one Wikipedia page to the Wikipedia page about Rome.
Notice that it is not enough to find the word Rome with a hyperlink, Rome has to be linked to this specific page: "https://en.wikipedia.org/wiki/Rome"
Link connections
The Wikipedia pages are written in HTML, a markup language. With the appropriate syntax, a word or phrase can be annotated and turned into a hyperlink, which allows people to click the word/phrase and open a new Wiki page. You can see a couple of such link in the screenshot below:

Those annotated hyperlinks are what your program should locate and follow. To try and avoid some loopholes, we are going to restrict the links you are allowed to follow to the links within the div named content, which is roughly this part of the wiki page:

Loopholes

You are only allowed to query Wikipedia wiki pages on the internet. Your answer may not communicate with anything else. E.g., you are not allowed to download someone else's answer and run it.
You may not communicate with any wiki APIs or Wiki "meta" pages, such as the "Category" page.

This community is very clever and imaginative. As more loopholes arise, those may be explicitly disallowed in the challenge. The spirit of the challenge is to find a series of links a user could click in the content of wiki pages.
Input
Your code should take one of the two as input:

a string that, when appended to https://en.wikipedia.org/wiki/, gives a valid link to a valid Wikipedia page;
a string with the link already built for you.

You may assume there is a valid path between the input page and Rome's page.
Output
Your program should output the path taken so that the lengths you claim are actually verifiable. It is up to you to output the path in any way that is human readable and understandable. Some suggestions include:

the successive path links
the successive page names

Scoring
This is code-golf, so we care about byte count. You are allowed to define a string literal containing exactly these characters in this order: "https://en.wikipedia.org/wiki/" and not count it for the byte count of your program.
Test cases
At the time of writing, these pages had a 1-link path to Rome:
"https://en.wikipedia.org/wiki/Italy"
"https://en.wikipedia.org/wiki/A.S._Roma"
"https://en.wikipedia.org/wiki/Vatican_Hill"
"https://en.wikipedia.org/wiki/Europe"
"https://en.wikipedia.org/wiki/European_Union"

And these pages had a path of length at most 2 to Rome:
"https://en.wikipedia.org/wiki/Continent"
"https://en.wikipedia.org/wiki/France"

(feel free to suggest more!)
Please submit your code with a screenshot or a TIO link showing a path from a Wikipedia page of your choosing to Rome.

JavaScript (Node.js), 335 - 30 = 305 bytes
I'm not very happy with it, but let's get the ball rolling.
Takes input as a page name. Prints a list of page names, separated with linefeeds.
u=>(i=0,g=a=>(m=a.find(u=>u=='Rome'))?console.log((h=v=>g[v]==u?u:h(g[v])+`
`+g[v])(m)+`
`+m):require('https').get('https://en.wikipedia.org/wiki/'+(U=a[i++]),r=>r.on('data',s=>h+=s,h="").on("end",_=>g([...new Set([...a,...((h.match(/mw-b.*mw-d/s)||[''])[0].match(/(?<=href=".wiki.).*?(?=")/g)||[]).map(v=>(g[v]=g[v]||U,v))])]))))([u])

(Don't) try it online!
Example I/O
f("Commodore_64")

Results in:
Commodore_64
Christmas
Rome

(Don't) try it online! Literally lol! :D

What is taking over 60s on TIO if I didn't even call the function? Is the code doing some sort of setup?

@RGS TIO has been quite disturbed today, so these 60 seconds are probably spent doing nothing at all.

I tried your answer and I got ENOTFOUND

@Xwtek This is a connection error. You may be behind a restrictive firewall, or your environment may not support SSL connections. (Or something else goes wrong ... I really can't tell for sure.)

Python 3 + BeautifulSoup 4, 269 - 30 = 239 bytes
import bs4,requests as r
k=l=[(input(),)]
while'Rome'!=k[-1]:k=l.pop(0);l+=[k+(h[6:],)for h in[l.get('href')for l in bs4.BeautifulSoup(r.get('https://en.wikipedia.org/wiki/'+k[-1]).content).find(id='content').find_all('a')]if None!=h>h[:6]=='/wiki/'[':'in h:]]
print(k)

Input and output are page titles.
Example outputs
OVS_(company) => ('OVS_(company)', 'Albania', 'Rome')
Code_golf => ('Code_golf', 'Source_code', 'Free_speech', 'Rome')

Java 10, 451 418 - 30 = 388 bytes
p->{for(;;)for(var t:p){if(t.endsWith(" Rome"))return t;String w="https://en.wikipedia.org/wiki/",c=t;try{try(var b=new java.io.BufferedReader(new java.io.InputStreamReader(new java.net.URL(w+t.replaceAll(".*?(\\S+)$","$1")).openStream()))){for(;(i=b.readLine())!=null;)c+=i;}for(var h:c.replaceAll(".*ole=.mai(.*)id=.catl.*","$1").split("href=./wiki/"))p.add(t+" "+h.substring(0,h.indexOf('"')));}finally{continue;}}}

Extremely slow would be an understatement, but it works..
Takes just the page (wrapped into a CopyOnWriteArraySet<String>) as input. Outputs the pages space-delimited as String.
Example run locally:
Input:  "Java_(programming_language)"
Output: "Java_(programming_language) Rust_(programming_language) Rome"

Explanation:
p->{                           // Method with Set<String> parameter and String return-type
  for(;;)                      //  Loop indefinitely:
    for(var t:p){              //   Loop over each String `t` in the input-CopyOnWriteArraySet:
                               //   (it's a CopyOnWriteArraySet, since we otherwise wouldn't
                               //    be able to add while iterating)
      if(t.endsWith(" Rome"))  //    If the current String `t` ends with " Rome"
        return t;              //     Return it as result
    String w="https://en.wikipedia.org/wiki/",
                               //    String with the base url of Wikipedia
           c=t;                //    Content-String (starts at `t` instead of "" to save a byte)
    try{try(var b=new java.io.BufferedReader(new java.io.InputStreamReader(new java.net.URL(w
                               //    Go to the Wikipedia website
          +t.replaceAll(".*?(\\S+)$","$1")
                               //    with everything after the last space in `t` as page
            ).openStream()))){ //    And open this website as a try-with-resources BufferedReader
        for(;(i=b.readLine())!=null;)
                               //     Read all lines of the page:
          c+=i;}               //      And append each line to the content-String
      for(var h:c.replaceAll(".*ole=.mai(.*)id=.catl.*","$1")
                               //    Take the content between 'ole="mai' and 'id="catl':
                               //    ('role="main"' and 'id="catlinks"')
                 .split("href=./wiki/"))
                               //    Split it on 'href="/wiki/', and loop over each part:
        p.add(                 //     Add to the input-Set:
           t+" "               //      The current String with an appended space
           +h.substring(0,h.indexOf('"')));
                               //      Appended with the leading part up until the first '"'
    }finally{                  //   If any error occurs accessing the page (i.e. going to "wiki/.")
      continue;}}}             //    Skip it, and go to the next iteration

all_licenses: Creative Commons - Attribution Share-Alike - https://creativecommons.org/licenses/by-sa/4.0/


text:
Any lips images
Introduction
The \$n\$-ellipse is a generalization of the ellipse with possibly more than two foci. Specifically, given \$n\$ points on the plane, called foci, the \$n\$-ellipse is the set of points of the plane whose sum of distances to the \$n\$ foci is equal to a constant \$t\$.
This challenge is about plotting the \$n\$-ellipse together with its interior; that is, the set of points whose sum of distances to the \$n\$ foci is less than or equal to equal to \$t\$. Note that the resulting set is always convex.
To simplify, only points with integer coordinates  need to be considered.
The challenge
Input:

Number of points \$n\$: positive integer;
List of \$n\$ foci (possibly repeated) with integer coordinates, \$(x_1, y_1)\$, ..., \$(x_n, y_n)\$;
Threshold \$t\$: positive integer.

Output:
An image representing all points \$P\$ with integer coordinates such the sum of Euclidean distances from \$P\$ to the \$n\$ foci is less than or equal to \$t\$.
Each pixel in the image should correspond to a point with integer coordinates; that is, pixel size is \$1 \times 1\$. Alternatively, you can use a finer resolution (smaller pixels), or vector graphics.
The image should consistently use two different colours for points satisfying the condition ("active" pixels) or not satisfying it ("inactive").
Additional rules

Graphical output is required, in any format. (ASCII art is not allowed because of size limitations and aspect ratio).
Both axes should have the same scale. The \$x\$ axis should be horizontal, and can consistently increase left to right or right to left. Similarly, the \$y\$ axis should be vertical and can consistently increase upwards or downwards.
Axis labels, auxiliary grid lines and similar elements are allowed.
The output image can have an arbitrarily large "frame" of inactive pixels around the set of active pixels.
The set of active points is guaranteed to be non-empty.
Input format is flexible as usual. A program or a function can be provided. Standard loopholes are forbidden.
The code should work in theory for inputs containing arbitrarily large numbers. In practice, it is acceptable if the program is limited by time, memory or data-type restrictions.
Shortest code in bytes wins.

Test cases
Input is shown as a list of \$n\$ foci defined as coordinate pairs, followed by \$t\$, and an optional comment.
In the output images, \$x\$ axis increases left to right, \$y\$ axis increases upwards.
(5,8), 100  % A circle

(0,0), (70, 150), 220  % An ellipse

(-100, 0), (100, 0), (100, 0), 480  % Repeated point

(-90, -90), (-90, 90), (90, -90), (90, 90), (90, -90), 670  % Repeated; arbitrary order

(200, 600), (320, -60), (-350, 220), (-410, 130), (40, -140), 2100

(-250, -250), (-250, 250), (250, -250), 1000

(-250, -250), (-250, 250), (250, -250), 1200

(-390, 0), (-130, 120), (130, -120), (390, 0), 1180  % Finally, a pair of lips?

Sorry for a week title

I read through the link on acceptable input/output methods. Can we output a gray-scale image in the format of a matrix of floats between 0 and 1?

@RGS I think you mean this, which doesn't seem to have enough community support, so I'm going to say no (sorry)

Now I know where guitar picks come from!

@Kaddath Those were my thoughts too (guitar player here)

@LuisMendo What about this? By the way, I like the title.

@DavidConrad Sure! It’s a standard format, so go ahead. And thanks :-)

Jelly, 36  35 bytes
«/_⁹r»/+¥,þ/_Ɱ⁸²§½S>⁹µ;L;ZL$;1ṚK”P;

Try it online!
A full program that takes a list of lists of integers as the first argument, representing the foci, and the threshold as an integer as its second argument. Prints a PBM file to STDOUT.
Example

First argument: (0,0), (7, 15)
Second argument: 220
Output (converted to PNG):

Python 3 + numpy + pylab, 168 163 156 bytes
import numpy,pylab
f,t=eval(input())
s=max(map(abs,sum(f,())))+t
k=numpy.r_[-s:s+1]
pylab.imsave('a.png',sum(((k-x)**2+(k[:,None]-y)**2)**.5for x,y in f)>t)

Outputs to a file called a.png, the y-axis increases downwards.
Sample outputs (click for full-res versions)
[(5, 8)], 100:

[(0, 0), (70, 150)], 220:

[(-90, -90), (-90, 90), (90, -90), (90, 90), (90, -90)], 670:

[(-390, 0), (-130, 120), (130, -120), (390, 0)], 1180:

Python 2, 152 bytes
f,t=input()
s=max(map(abs,sum(f,())))+t
w=s*2+1
k=range(-s,s+1)
print'P1',w,w
for y in k:
 for x in k:print+(sum(((a-x)**2+(b-y)**2)**.5for a,b in f)>t)

Try it online!
Outputs a PBM file to STDOUT. Sample output:

Any reason not to output to a file called a to save 4 bytes?

@Noodle9 the imsave function needs the file extension to determine the desired file format.

APL (Dyalog Unicode), 67 bytes (SBCS)
⎕IO←0

+{(⎕NEW'Bitmap'(⊂'Cbits'(⍵≥+⌿⍺∘.(.5*⍨-+.×-)(⊢,-)⍳2×⍵ ⍵))).MakePNG}⊢

NB

This image is very low contrast (made from a boolean matrix) - the output can be white interior shape on black background by multiplying the boolean matrix:
+{(⎕NEW'Bitmap'(⊂'Cbits'(16777215×~⍵≥+⌿⍺∘.(.5*⍨-+.×-)(⊢,-)⍳2×⍵ ⍵))).MakePNG}⊢
Images are transposed compared to many other solutions, but you can flip the indices of each focus
Only works on Dyalog for Windows

Explanation
This function is a 3-train (fork), the arguments to the inner function are the results of the outer functions:
+

+ (plus): Translate the image by adding distance to the foci (please comment if this is a misinterpretation of the challenge)
⊢

⊢ (right): given two arguments (left and right), return the right argument
APL is parsed (glossing over some binding rules) as Brackets, long Right scope, short Left scope. We break it down as follows:
⍳2×⍵ ⍵

Indices from 0 to 2×⍵ in 2 dimensions (our integer pixels)
(⊢,-)⍳2×⍵

(⊢,-) (Same catenate negate) to cover positive and negative coordinates
(.5*⍨-+.×-)

Euclidean distance from focus to pixel...
⍺∘.(.5*⍨-+.×-)

... applied between each focus and every pixel
+⌿⍺∘.(.5*⍨-+.×-)

Sum the distances between all foci and each pixel (n-ellipse)
⍵≥+⌿⍺∘.(.5*⍨-+.×-)

Boolean matrix where 1 indicates interior (active) pixels (i.e. sum of distances between foci and pixel is less than t)
(⎕NEW'Bitmap'(⊂'Cbits'(*boolean matrix*))).MakePNG

Output signed integer PNG. This can be written to file using
∇  WritePNG png;tn
   tn←'img.png'⎕NCREATE 0
   png ⎕NAPPEND tn 83
   ⎕NUNTIE tn
∇

Output Images
First is to demonstrate, the written PNG has very low contrast
f ← +{(⎕NEW'Bitmap'(⊂'Cbits'(⍵≥+⌿⍺∘.(.5*⍨-+.×-)(⊢,-)⍳2×⍵ ⍵))).MakePNG}⊢
WritePNG 5 8 f 100

Below I'm using the black and white version.
WritePNG (0 0)(70 150) f 220

WritePNG (¯100 0)(100 0)(100 0) f 480

Very resource hungry algorithm so I did a low res version of this
WritePNG (20 60)(32 ¯6)(¯35 22)(¯41 13)(4 ¯14) f 210

Can you perhaps include a couple of screenshots of your results?

JavaScript (ES7), 212 196 bytes

with(Math)f=(c,l,...p)=>{m=l-max(...p)
c.height=c.width=s=min(...p)+l+m
for(i=0;i<s;i++)for(j=0;j<s;j++){for(d=k=0;1/p[k];)d+=hypot(p[k++]+m-i,p[k++]+m-j)
d>l||c.getContext`2d`.fillRect(i,j,1,1)}}

eval(`f(c,${e.value})`)
input{position:fixed}
<input id=e oninput=eval(`f(c,${e.value})`) value="100,-25,-25,-25,25,25,-25"><canvas id=c>

Outputs via first parameter which is a canvas element to draw on, second parameter is the threshold, then the remaining parameters are the loci. Edit: Saved 16 bytes thanks to @Arnauld, however the code is now dead slow and will trigger slow script warnings for large thresholds.

@LuisMendo Running the snippet itself doesn't actually trigger the input event that calls the function, so the suggested input doesn't run unless you edit the value e.g. by appending a space.

196 bytes, I think (not really tested).

@LuisMendo I've added an extra line to calculate the suggestion automatically.

@Arnauld Boy that's slow :-(

Haskell + Gloss, 165 bytes
import Graphics.Gloss
i=fromIntegral
h t=[i(-t)*3..i t*3]
d f t=display(InWindow""(t*3,t*3)(0,0))red$Line[(x,y)|x<-h t,y<-h t,i t>sum[sqrt$(x-u)^2+(y-v)^2|(u,v)<-f]]

Draws the shapes to the screen. It sometimes draws the images REALLY BIG, so I have cropped accordingly.
main = d [(5,8)] 100

main = d [(0,0), (70, 150)] 220

main = d [(-100, 0), (100, 0), (100, 0)] 480

main = d [(-250, -250), (-250, 250), (250, -250)] 1000

Red, 300 bytes
Red[]f: func[p t][a: :absolute
m: last sort collect[foreach n p[keep a n/x keep a n/y]]s: t + m * 2
u: as-pair s s i: make image! reduce[u]k: 0 repeat y s[repeat x s[d: 0
foreach a p[d: d +(sqrt x - t - m - a/x ** 2 +(y - t - m - a/y ** 2))]k: k + 1
if d <= t[i/:k: 0.0.255]]]save/as %1.jpg i 'jpeg]

f [5x8] 100

f [0x0 70x150] 220

f [-100x0 100x0 100x0] 480

f [200x600 320x-60 -350x220 -410x130 40x-140] 2100

f [-390x0 -130x120 130x-120 390x0] 1180

Note: I scaled all the images to 256x256 pixels and croped the last two images so that they don't take too much space - they had a large "frame"

Applescript + grapher, 601
This will almost certainly be the longest answer, but I thought this would be a fun challenge in Applescript.
on f(l, t)
set y to 0
tell application "Grapher" to activate
tell application "System Events"
keystroke "n" using command down
keystroke return
keystroke "a" using command down
repeat with d in l
keystroke "sqrt((x-"&d's item 1&")^2)+(y-"&d's item 2&")^2))+"
set y to y+d's item 2
end repeat
click application process "Grapher"'s menu bar 1's menu bar item 8's menu 1's menu item 3
set c to l's items count
keystroke "             "&(y-t)/c as text&" "&(y+t)/c as text&"     "
keystroke "c" using command down
keystroke "             "
keystroke "v" using command down
keystroke return&"0<"&t as text&return
end tell
end f

This is an applescript function.  It may be called as follows for the testcases:
my f({{5, 8}}, 100)
my f({{0, 0}, {70, 150}}, 220)
my f({{-100, 0}, {100, 0}, {100, 0}}, 480)
my f({{-90, -90}, {-90, 90}, {90, -90}, {90, 90}, {90, -90}}, 670)
my f({{200, 600}, {320, -60}, {-350, 220}, {-410, 130}, {40, -140}}, 2100)
my f({{-250, -250}, {-250, 250}, {250, -250}}, 1000)
my f({{-250, -250}, {-250, 250}, {250, -250}}, 1200)
my f({{-390, 0}, {-130, 120}, {130, -120}, {390, 0}}, 1180)

Output looks like this, e.g. for the 5th testcase:

This looks a lot like natural language:-)

@LuisMendo Apparently that's the idea https://en.wikipedia.org/wiki/AppleScript#Natural_language_metaphor

Very much Apple-like

MATLAB + DIPimage toolbox, 133 121 117 111 bytes
(shaved off 12 16 bytes thanks to flawr and LuisMendo)
function s(c,r),c=c-min(c)+r;a=zeros(max(c)+r);l='corner';for x=c',a=a+hypot(xx(a,l)-x(1),yy(a,l)-x(2));end,a>r

Use:
c = [-390, 0; -130, 120; 130, -120; 390, 0];
r = 1180;
s(c,r)

In a more readable fashion:
function s(c,r)
c=c-min(c)+r;           % offset coordinates so all points within shape have non-negative coordinates
a=zeros(max(c)+r);      % compute image size and create empty output image
l='corner';             % long argument used twice below
for x=c'
   a=a+hypot(xx(a,l)-x(1),yy(a,l)-x(2)); % add distance to each point
end
a>r                     % threshold and display (leaving semi-colon off causes graphical display of image)

Desmos, 50 49 bytes
\sum_{n=1}^c \sqrt{(x-a[n].x)^2+(y-a[n].y)^2}<=t

-1 byte from finding a new quirk in Desmos' syntax while working on another problem.
View it online
It just kinda... works. Input n in the variable c, t in the variable t, and the points as an array a of coordinates.
Lips example:

Guitar pick example:

Note: If you try to copy the equation from the editor, you'll find a bunch of \lefts and \rights and such. These have been golfed out of this answer, as you can paste this text in and it works. The editor automatically re-adds those when parsing input from the clipboard, but it accepts the code without them.
Note two: I'm not 100% sure if this counts due to the infill being transparent, but hopefully it's ok. If not, there's a couple options:

Stack a bunch of whole bunch of these equations on top of each other. I tried this and it turns out that a quirk of their rendering engine is that the fill color can never drop below #010101, while the outline is at #000000. Additionally, the area is a little larger than would be ideal because the outline looks like part of the fill.

Rewrite the n-ellipse equation in parametric form. I don't know if this is possible or not, but if it is, Desmos's enhanced visual options for parametric equations allows us to remove the outline.

Right tool for the job :-) Fill being half-transparent is ok

Bash + Standard utilities (but no graphics library), 194 190 186 bytes
t=$1
shift
L=H=$1
for n do
L=$[n<L?n:L]
H=$[n>H?n:H]
done
echo P2 $[L-=t,H+=t+1,H-L] $[H-L] 1
for((x=y=L;y<H;++x>=H?x=L,y++:0)){ bc -l<<<`printf "sqrt(($x- %d)^2+($y- %d)^2)+" $@`0\>$t;}

Try it online! (If you do, though, try a tiny example: even the circle test times out on TIO.)

Input is passed in the arguments: first \$t\$, then \$x_1\$, \$y_1\$, \$x_2\$, \$y_2\$, ..., \$x_n\$, \$y_n\$.
Output is a PGM image on stdout.  Save it in a file named something.pgm and view it in your favorite graphics program.
The x-axis goes from left to right, and the y-axis goes from top to bottom.  White is the background, and black is the n-ellipse being drawn.
For example, to view the first example (the circle), you could execute:
lips 100 5 8 > lips-circle.pgm

(where the program is named lips).  Then open the imagelips-circle.pgm.  Here's the result:

Here's the second test, the output of lips 220 0 0 70 150 > lips-ellipse.pgm:
Next is lips 480 -100 0 100 0 100 0 > lips-repeatedpoint.pgm:

Here is lips 670 -90 -90 -90 90 90 -90 90 90 90 -90 > lips-repeated-arbitaryOrder.pgm:

The next test is lips 2100 200 600 320 -60 -350 220 -410 130 40 -140 > lips-shape1.pgm:

This script is very slow (but runnable).  I will post more sample images as my computer gets around to finishing them :) ....
Well, after waiting overnight again, the other tests are finally done!

Here's the guitar pick: lips 1000 -250 -250 -250 250 250 -250 > lips-guitarpick.pgm

The next test is lips 1200 -250 -250 -250 250 250 -250 > lips-shape2.pgm:

And finally the pair of lips! lips 1180 -390 0 -130 120 130 -120 390 0 > lips-pairOfLips.pgm:

Shadertoy (GLSL) 125 bytes + input data
vec2 a[]=vec2[](vec2(-390, 0),vec2(-130,120),vec2(130,-120),vec2(390,0));
float d=1180.;

void mainImage(out vec4 o,vec2 c){c-=iResolution.xy/2.;o-=o;for(int i=0;i<a.length();o.a+=length(c-a[i++]));o.b=step(o.a,d);}

Shadertoy link for the last testcase.
As the input array's size is known, this could be further reduced by replacing the a.length() by n.

Why is this non-competing?

Also, why don't you do the further reduction you suggest in your answer?

it doesn't receive input, I could change it to a uniform value but that's still not like in other languages.

Desmos, 39 bytes

\distance((x,y),\ans_0).\total<=\ans_1

The other Desmos answer to this challenge is invalid because it assumes that the input is stored in hardcoded variables, which is heavily discouraged.
Instead, this program takes input through \ans, which is an acceptable form of input.
Input the list of points in the first line, and the threshold in the second line.
Try It On Desmos!
Try It On Desmos! - Prettified


text:
Alternating Triangles
Given a strictly positive integer n (therefore 0 isn't a valid test case), produce an approximate triangle of height n.
A non-programmatic process of drawing the picture
Initially we start with the base of the triangle.
|

So, we want to draw a triangle of a height of 5. First we know that all the |'s align on a straight line, and there is a missing | on every even position.
|

|

|

Then, we insert the /'s onto these empty lines, where every / has 1 more preceding space than the next /. The lowest / starts at 1 space.
|
  /
|
 /
|

More reference outputs + Sample program
Here's what the program should output for inputs 1 to 9. A sample program is available if you still don't understand the specification.
For those that don't see that it's a triangle: Take a look at this. Scroll the picture really quickly. You will see the two sides of a triangle.
==== 1: ====
|
==== 2: ====
 /
|
==== 3: ====
|
 /
|
==== 4: ====
  /
|
 /
|
==== 5: ====
|
  /
|
 /
|
==== 6: ====
   /
|
  /
|
 /
|
==== 7: ====
|
   /
|
  /
|
 /
|
==== 8: ====
    /
|
   /
|
  /
|
 /
|
==== 9: ====
|
    /
|
   /
|
  /
|
 /
|

Specification

Leading/Trailing whitespace is allowed.
The string has to be joined with newlines, outputting a string list is not allowed.

Is a list of strings acceptable output from a function for this challenge?

It's an angle, not a triangle!

05AB1E, 17 14 13 11 bytes
L'/ú€'|I£R»

-3 bytes thanks to @Grimmy.
-1 byte after getting inspiration from @MagicOctopusUrn.
Try it online or verify all test cases.
Explanation:
L            # Push a list in the range [1, (implicit) input]
             #  i.e. 5 → [1,2,3,4,5]
 '/ú        '# Pad "/" with that many leading spaces
             #  → [" /","  /","   /","    /","     /"]
    €'|     '# Put a "|" in front of each item
             #  → ["|"," /","|","  /","|","   /","|","    /","|","     /"]
       I£    # Only leave the first input amount of items
             #  → ["|"," /","|","  /","|"]
         R   # Reverse it
             #  → ["|","  /","|"," /","|"]
          »  # And join it by newlines
             #  → "|\n  /\n|\n /\n|"
             # (after which the result is output implicitly)

14

Alternative 14 (kinda cute imo).

@Grimmy Oh, I like that second approach! :) Thanks (I added both).

LRDÈ*;ʒ„|/Nèú= Alter-alternative

@MagicOctopusUrn So many alternatives are possible actually. Just thought about this one as well: LRāÈ·/ā„/|sèú». I have the feeling 13 might be possible, but I'm not seeing it.

@MagicOctopusUrn Wait, the first one is 13 bytes by using the map as for-each.. :)

@MagicOctopusUrn Found an 11-byter. :)

Husk, 12 bytes
↔↑ṁe"|"¡Θ" /

Try it online!
Builds the infinite triangle upside-down, then takes the required number of lines and reverses them before printing.
Explanation
↔↑ṁe"|"¡Θ" /
       ¡        Repeat and accumulate results:
        Θ          prepend a space
         " /       starting from the string " /"
                   (this will create all the lines of the slanted side)
  ṁ             For each line:
   e"|"            put it in a list with a "|" line
  ṁ             and merge all these lists together
 ↑              Take the number of lines required by the input
↔               Reverse the result

Python 2, 45 bytes
def f(n):print n%2*'|'or n/2%n*' '+'/';f(n-1)

Try it online!
A function that prints, terminating with error. The %n in n/2%n is just to give an error when n falls to 0, but is harmless otherwise.

As a program
50 bytes
n=input()
while n:print n%2*'|'or n/2*' '+'/';n-=1

Try it online!

Using zero-div/mod to break out of things is actually really creative and I don't think I've seen it before! Gotta keep this one in mind.

Haskell, 48 bytes
unlines.reverse.(`take`f" /")
f c="|":c:f(' ':c)

Try it online!
f" /" generates an infinite (reversed) approximate triangle, the first line is mostly formatting.

This is a really really really cool solution. I think people haven't upvoted because they haven't noticed the elegance of the recursion used here... As for me, I'm still digesting it. Good job!

C (gcc), 52 51 bytes
f(n){for(;n--;)printf(n&1?"%*c\n":"|\n",n/2+2,47);}

Try it online!

I beat your solution by a hair. I'm surprised you didn't come up with the same thing I did.

APL (Dyalog Unicode), 21 20 bytesSBCS
⊖(0⌊-\∘⍳)⌽⊢↑⍤0⍴∘'|/'

Try it online!
Edit: Use ↑⍤0 instead of ↑¨ to avoid an extraneous use of ↑.
An anonymous tacit function. This is an improvement over Graham's APL+WIN solution using modern APL.
I was about to post a 24-byter when -\⍳n randomly struck my brain. It is an expression that yields first n terms of 0 -1 1 -2 2 -3 3 ..., so applying 0⌊ yields 0 -1 0 -2 0 -3 0 ... which is perfect for row-wise rotation vector.
How it works
⊖(0⌊-\∘⍳)⌽⊢↑⍤0⍴∘'|/'  ⍝ Input: n
              ⍴∘'|/'  ⍝ Repeat '|/' to length n
          ⊢↑⍤0        ⍝ Create a n-by-n matrix whose 1st column is the above
                      ⍝   and the rest is blank
         ⌽            ⍝ Rotate left each row:
 (  -\∘⍳)             ⍝   First n values of 0 -1 1 -2 2 -3 3 ...
  0⌊                  ⍝   Minimum with 0; 0 -1 0 -2 0 -3 ...
                      ⍝ (Negative rotate left is rotate right)
⊖                     ⍝ Reverse vertically

brainfuck, 168 bytes
,[->>>+<[-<+>>-]>[<+>->]<<<<]>>>>>>>++>++[-<[-<++>]<[->++<]>>]<<++++++[-<+++++++>]<[-<+<+++>>]++++++++++<+++++<--<[->.>>.<<<]<[[->+>>>>>.<<<<<<]>>>.>.<<.>>.<<<[-<+>]<-]

Try it online, with 10 as input. There is substantial room for improvement for sure. I should try different memory layouts for the constants, for example. My pointer walks around way too much.
The commented code:
Divide input by two and get the mod as well
Mem layout is
input | quotient | remainder | ifelse flag | 0
,[->>>+<[-<+>>-]>[<+>->]<<<<]
Mem: ^0 | quotient | remainder | 0 | 0
Build 32 which is the SPACE character
>>>>>>>++>++
Mem: 0 | quot | rem | 0 | 0 | 0 | 0 | 2 | ^2
[-<[-<++>]<[->++<]>>]
Mem: 0 | quot | rem | 0 | 0 | 0 | 0 | 32 | ^0
Build 124 and 47 for the vertical bar and the slash
<<
++++++[-<+++++++>]<[-<+<+++>>]++++++++++<+++++<--
Mem: 0 | quot | rem | ^124 | 47 | 10 | 0 | 32
If there is a remainder print the loose vertical bar
<[->.>>.<<<]<
Mem: 0 | ^quot | 0 | 124 | 47 | 10 | 0 | 32
while there is something in the quotient
[
  print those many spaces
[->+>>>>>.<<<<<<] print as many spaces as needed
  then a slash
>>>.
  then a newline
>.
  then a vertical bar
<<.
  then a newline
>>.<<<
reset the space counter and decrement it
[-<+>]<-
] (end while)

that you can try at a different interpreter and to which you can pass different input numbers more easily. For example, try typing \10 in the input bar. Then pass the commented code over this Python script to remove the comments and get the byte count.

Python 3, 66 56 55 bytes
Saved a byte thanks to kaya3!!!
def f(n):
 if n:print((-~n//2*' '+'/','|')[n&1]);f(n-1)

Try it online!

To save one byte, you can use if instead of while, and f(n-1) instead of n-=1.

@kaya3 Nice one - thanks! :-)

J, 24 bytes
>@}.&,i.;&'|'@{.&'/'@->:

Try it online!
-4 bytes thanks to Bubbler

29 bytes. Nice job on the replicating matrix btw.

@Bubbler thanks.  I woke up with a totally new approach for 28

25, no parens.

Fabulous.  We're closing in on APL.... though this feels like the limit now.

... And here is 24.

Nice.  I'd used that negative {. trick in another approach I'd tried but didn't think to use it here.

APL+WIN, 36 33 30 bytes
3 bytes saved by incorporating bubbler's row rotation method
Prompts for integer:
    ⊖(0⌊-\⍳n)⌽(n,n)↑((n←⎕),1)⍴'|/'

Try it online! Courtesy of Dyalog Classic

30 bytes using excessive use of stranding and reducing m part into a train.

24 bytes as a full train, with tweaking some parts. Nice job, I couldn't find such an elegant expression without seeing your code.

@Bubbler Thanks but unfortunately my ancient APL+WIN does not support chains

Oh, didn't know that. May I post it as a separate answer then?

@Bubbler Sure. I am all for showing how APL can compete with the pure golfing languages

Jelly, 14 13 bytes
H⁶ṁ;”/)”|ÐoṚY

Try it online!
A monadic link taking an integer and returning a list of Jelly strings. If a single newline-separates string is needed, append Y for a cost of a byte. Thanks to @JonathanAllan for saving a byte!

There is 4 spaces in the first line before the "/" instead of 2, and I think the newline is needed

Sorry now fixed

Since any implicit make_range performs an int cast, mould-like, ṁ, can save a byte with halve H over :2 - TIO.

PowerShell, 42 bytes
"$args"..1|%{((" "*($_/2)+"/"),"|")[$_%2]}

Try it online!
Loops from input $args down to 1, each iteration choosing whether to output spaces and a /, or the | character based on a modulo-index into an array. Default output gives us newlines for free. Ho-hum.

Java (OpenJDK 8), 88 84 bytes
x->{for(int i=x,j=i+2;i-->0;j--)System.out.printf((i%2<1?"|\n":"%"+j/2+"s\n"),"/");}

Try it online!
If Java's output methods weren't so long, I'd get close to John's R submission!
Edit:
-4 bytes thanks to @Kevin Cruijssen!
Also the link led to an older 91 bytes version, fixed that now...

84 bytes: -2 by removing the parenthesis around (i--%2<1)?, and an additional -2 by changing the int i=x+1,j=i+1;i>1; to int i=x,j=i+2;i-->0; and the i--%2 to i%2.

Oh, and welcome to CGCC btw! If you haven't seen it yet, Tips for golfing in Java and Tips for golfing in  might both be interesting to read through. Enjoy your stay!

Charcoal, 18 bytes
Ｎθ↙⊘θＵＥ⁰¦¹Ｆ⊘⊕θ«↑↑¹

Try it online! Link is to verbose version of code. Explanation:
Ｎθ

Input n.
↙⊘θ

Print the diagonal line of the appropriate length.
ＵＥ⁰¦¹

Space the rows out.
Ｆ⊘⊕θ«↑↑¹

Fill in the vertical line on alternate lines.

Perl 5 -n, 36 bytes
say$_%2?$"x(1+$_/2).'/':'|'while$_--

Try it online!

Jelly, 23 bytes
HĊ”|ẋż³HḞR¤” ẋ$;€”/¤ẎṚY

Try it online!
It's been a while since I've golfed in Jelly, so this answer is probably embarrassingly long.

PHP, 76 57 bytes
for(;$a=$argn--;)echo$a%2?"|
":str_repeat(' ',$a/2)."/
";

Try it online!
I feel there should be much better but can't put my finger on it yet.. I also didn't find how to use recursive functions with PHP7 arrow notation.. well..
EDIT: Actually, a basic loop is still better for PHP than recursion

R, 75 61 bytes
Thanks again, Giuseppe! Forgot that cat does pasting itself.
for(i in scan():1)cat(`if`(i%%2,'|',c(rep('',i/2),'/')),'\n')

Try it online!

61 bytes. Neat trick with the Reduce(paste,...), though!

Also, btw, if you want to notify someone who's commented on your post, you can do @. Or you can do the same with users in the (often empty) R golfing chatroom

4, 171 bytes
3.6006260132602476031061101612026401020000127908906554819090552999940099999079098993139912214131211599141161115815500503615009816317991281750111717119502503616009199991194

Try it online!
Explanations
3.    start of code
60062 assign half ASCII of pipe
60132 space
60247 slash
60310 endl
61101 int one
61202 int two
64010 int ten
2000012 multiply half-pipe by two for a pipe
790 get input
890 while there's still input
65548 char zero
1909055 decrease input char by char zero to get result
2999940 multiply previous result by ten (to make way for current char input)
0999990 put current result
790 get input again
9 end of loop
======== At this point we already got the int n
899 while (n != 0)
3139912 2141312 1159914 mod by 2 (n-[[n/2]]*2)
1161115 check odd or even
815     if odd
500 503 61500 9 print pipe and endl
816     if even
3179912 get n/2
817 501 1171711 9 print spaces
502 503 61600 9 print slash and endl
1999911 9 get n-1, end of loop
4       end of code

wow i had no idea this was a language

C (gcc), 50 bytes
f(n){for(;n;)printf(n--%2?"|\n":"%*s/\n",n/2,"");}

Takes as input an integer n and prints a triangle. It would look more realistic and save 2 bytes if n was not divided by 2.
Try it online!

"It would look more realistic and save 2 bytes if n was not divided by 2." Seems to be a compelling reason not to divide by 2.

@CodyGray The output format is restricted. I have to.

Japt -R, 16 bytes
Çg['|'/iSp°Zz]Ãw

Try it

Python 2, 52 bytes
i=input()
while i:print(' '*(i/2)+'/','|')[i%2];i-=1

Try it online!

MATL, 22 bytes
:2&\w~*"@:~'|/'X@)hXhP

Try it online!

JavaScript (ES6), 48 bytes
f=n=>n?(n&1?`|
`:' '.repeat(n/2)+`/
`)+f(n-1):''

Try it online!

Ruby, 44 bytes
->n{(1..n).map{[?|," "*(n/2)+?/][(n-=1)%2]}}

Try it online!

JavaScript (Node.js), 47 bytes
f=(n,s=`/
`,v=`|
`)=>--n?f(n,v,s<v?' '+s:s)+v:v

Try it online!

Bash, 68 bytes
f(){ for((i=$1;i-->0;)){((i%2))&&printf %$[2+i/2]s\\n /||echo \|;};}

Try it online!
Don't golf in bash that often, so tips appreciated.

Go, 94 bytes
import."fmt"
func f(n int){for n!=0{if n%2==0{Printf("%*s/\n",n/2,"")}else{Println("|")}
n--}}

Port of my C answer.
Try it online!

Vyxal j, 15 bytes
ɾ\/꘍\|?ẋf$Y?wiṘ

Try it Online!
An attempted port of the 05AB1E answer, but not really...