Third time the charm Your task, if you wish to accept it, is to write a program that outputs a positive integer (higher than 0). If the source code is duplicated the output must remain the same. The tricky part is that if the source code is typed three times (triplicated?) the output will be multiplied by 3.
Rules

You must build a full program. That is, your output has to be printed to STDOUT.

The initial source must be at least 1 byte long.

Both the integers must be in base 10 (outputting them in any other base or with scientific notation is forbidden).

Your program must not take input (or have an unused, empty input).

Outputting the integers with trailing / leading spaces is allowed.

Leading Zeroes are allowed only if the numbers of digits is consistent eg: 001 - 001 - 003 or 004 - 004 - 012

You may not assume a newline between copies of your source.

This is code-golf, so the shortest (original) code in each language wins!

Default Loopholes apply.


Example
Let's say your source code is Abc and its corresponding output is 4. If I write AbcAbc instead and run it, the output must still be 4. However if I write AbcAbcAbc and run it, the output must be 12.

Shamelessly stolen Derived from Mr. Xcoder's challenge
Wumpus, 6 bytes

{~)
@O


Try it online!
Try it doubled!
Try it tripled!

Prints 1 and 3.

Explanation

I found a ton of 6-byte solutions by brute force search, but none for 5 bytes. That doesn't necessarily mean there aren't any at 5 bytes but they'd probably use weird characters or something.

I ended up picking this solution because it doesn't print any leading zeros (most of them do) and it has some interesting control flow. Let's start with the single program:



So the executed code is:

{~)O@

{   Turn the IP left by 60°.
~   Swap two implicit zeros on the stack, does nothing.
)   Increment the top zero to 1.
O   Print it.
@   Terminate the program.


Easy enough. Now the doubled program. Since the first line gets appended onto the second line, the grid extends to width 5 (and height 3) which changes the control flow significantly:



The IP goes around that loop exactly once, so the executed code is:

{~){~)){~O@

{~) As before, we end up with a 1 on top of the stack.
{   Turn left by 60° again.
~   Swap the 1 with the 0 underneath.
))  Increment the zero to 2.
{   Turn left by 60° again.
~   Swap the 2 with the 1 underneath.
O   Print the 1.
@   Terminate the program.


Finally, the tripled program is quite similar to the doubled one, but we get a couple more important commands onto that third line:



So the executed code is:

{~){~)){~~)O@

{~){~)){~
    As before. We end up with a 1 on top of the stack and a 2 underneath.
~   Swap the 1 with the 2 underneath.
)   Increment the 2 to a 3.
O   Print the 3.
@   Terminate the program.