## test.md
module Test

Writing and running tests

This module provides a testing framework, and is used in the official suite that tests the specification. All its functions emit output conforming to the [Test Anything Protocol](https://testanything.org).

Also see [Writing and running tests in Raku](/language/testing).

# [Methods](#module_Test "go to top of document")[§](#Methods "direct link")

## [sub plan](#module_Test "go to top of document")[§](#sub_plan "direct link")

```raku
multi plan(Cool:D :skip-all($reason)!)
multi plan($number_of_tests)
```

Specify the count of tests -- usually written at the beginning of a test file.

```raku
plan 15;   # expect to run 15 tests

```

In `subtest`s, `plan` is used to specify the count of tests within the subtest.

If a `plan` is used, it's not necessary to specify the end of testing with `done-testing`.

You can also provide a `:skip-all` named argument instead of a test count, to indicate that you want to skip all of the tests. Such a plan will call [`exit`](/routine/exit), unless used inside of a `subtest`.

```raku
plan :skip-all<These tests are only for Windows> unless $*DISTRO.is-win;
plan 1;
ok dir 'C:/'; # this won't get run on non-Windows

```

If used in a `subtest`, it will instead `return` from that `subtest`'s [`Callable`](/type/Callable). For that reason, to be able to use `:skip-all` inside a `subtest`, you must use a `sub` instead of a regular block:

```raku
plan 2;
subtest "Some Windows tests" => sub { # <-- note the `sub`; can't use bare block
    plan :skip-all<We aren't on Windows> unless $*DISTRO.is-win;
    plan 1;
    ok dir 'C:/'; # this won't get run on non-Windows
}
ok 42; # this will run everywhere and isn't affected by skip-all inside subtest

```

Note that `plan` with `:skip-all` is to avoid performing any tests without marking the test run as failed (i.e. the plan is to not run anything and that's all good). Use [`skip-rest`](#sub_skip-rest) to skip all further tests, once the run has started (i.e. planned to run some tests, maybe even ran some, but now we're skipping all the rest of them). Use [`bail-out`](#sub_bail-out) to fail the test run without running any further tests (i.e. things are so bad, there's no point in running anything else; we've failed).

## [sub done-testing](#module_Test "go to top of document")[§](#sub_done-testing "direct link")

```raku
sub done-testing()
```

Specify that testing has finished. Use this function when you don't have a `plan` with the number of tests to run. A `plan` is not required when using `done-testing`.

It's recommended that the `done-testing` function be removed and replaced with a `plan` function when all tests are finalized. Use of `plan` can help detect test failures otherwise not reported because tests were accidentally skipped due to bugs in the tests or bugs in the compiler. For example:

```raku
sub do-stuff {@};
use Test;
ok .is-prime for do-stuff;
done-testing;
# output:
1..0

```

The above example is where a `done-testing` fails. `do-stuff()` returned nothing and tested nothing, even though it should've returned results to test. But the test suite doesn't know how many tests were meant to be run, so it passes.

Adding `plan` gives a true picture of the test:

```raku
sub do-stuff {@};
use Test;
plan 1;
ok .is-prime for do-stuff;
# output:
1..1
# Looks like you planned 1 test, but ran 0

```

Note that leaving the `done-testing` in place will have no effect on the new test results, but it should be removed for clarity.

The `done-testing` function returns `False` if any test has failed or less tests were run than planned, it returns `True` otherwise.

## [sub ok](#module_Test "go to top of document")[§](#sub_ok "direct link")

```raku
multi ok(Mu $cond, $desc = '')
```

The `ok` function marks a test as passed if the given `$cond` evaluates to `True`. It also accepts an optional description of the test as second argument.

```raku
my $response; my $query; ...;
ok $response.success, 'HTTP response was successful';

```

In principle, you could use `ok` for every kind of comparison test, by including the comparison in the expression passed to `$cond`:

```raku
sub factorial($x) { ... };
ok factorial(6) == 720, 'Factorial - small integer';

```

However, where possible it's better to use one of the specialized comparison test functions below, because they can print more helpful diagnostics output in case the comparison fails.

## [sub nok](#module_Test "go to top of document")[§](#sub_nok "direct link")

```raku
multi nok(Mu $cond, $desc = '')
```

The `nok` function marks a test as passed if the given `$cond` evaluates to `False`. It also accepts an optional description of the test as second argument.

```raku
my $response; my $query; ...;
nok $query.error, 'Query completed without error';

```

## [sub is](#module_Test "go to top of document")[§](#sub_is "direct link")

```raku
multi is(Mu $got, Mu:U $expected, $desc = '')
multi is(Mu $got, Mu:D $expected, $desc = '')
```

Marks a test as passed if `$got` and `$expected` compare positively with the [`eq` operator](/routine/eq), unless `$expected` is a type object, in which case [`===` operator](/routine/===) will be used instead; accepts an optional description of the test as the last argument.

**NOTE:** the `eq` operator stringifies its operands, which means `is()` is not a good function for testing more complex things, such as lists: `is (1, (2, (3,))), [1, 2, 3]` passes the test, even though the operands are vastly different. For those cases, use [`is-deeply` routine](#sub_is-deeply)

```raku
my $pdf-document; sub factorial($x) { ... }; ...;
is $pdf-document.author, "Joe", 'Retrieving the author field';
is factorial(6),         720,   'Factorial - small integer';
my Int $a;
is $a, Int, 'The variable $a is an unassigned Int';

```

**Note:** if *only* whitespace differs between the values, `is()` will output failure message differently, to show the whitespace in each values. For example, in the output below, the second test shows the literal `\t` in the `got:` line:

```raku
is "foo\tbar", "foo\tbaz";   # expected: 'foo     baz'␤#      got: 'foo   bar'
is "foo\tbar", "foo    bar"; # expected: "foo    bar"␤#      got: "foo\tbar"

```

## [sub isnt](#module_Test "go to top of document")[§](#sub_isnt "direct link")

```raku
multi isnt(Mu $got, Mu:U $expected, $desc = '')
multi isnt(Mu $got, Mu:D $expected, $desc = '')
```

Marks a test as passed if `$got` and `$expected` are **not** equal using the same rules as `is()`. The function accepts an optional description of the test.

```raku
isnt pi, 3, 'The constant π is not equal to 3';
my Int $a = 23;
$a = Nil;
isnt $a, Nil, 'Nil should not survive being put in a container';

```

## [sub is\_approx](#module_Test "go to top of document")[§](#sub_is_approx "direct link")

```raku
multi is_approx(Mu $got, Mu $expected, $desc = '')
```

**NOTE**: Removed with Rakudo release 2023.09, deprecated in older versions. Use `is-approx` instead.

## [sub is-approx](#module_Test "go to top of document")[§](#sub_is-approx "direct link")

```raku
multi is-approx(Numeric $got, Numeric $expected, $desc = '')
```

```raku
multi is-approx(Numeric $got, Numeric $expected, Numeric $abs-tol,
                    $desc = '')

```

```raku
multi is-approx(Numeric $got, Numeric $expected, $desc = '',
                    Numeric :$rel-tol is required)

```

```raku
multi is-approx(Numeric $got, Numeric $expected, $desc = '',
                    Numeric :$abs-tol is required)

```

```raku
multi is-approx(Numeric $got, Numeric $expected, $desc = '',
                    Numeric :$rel-tol is required,
                    Numeric :$abs-tol is required)

```

Marks a test as passed if the `$got` and `$expected` numerical values are approximately equal to each other. The subroutine can be called in numerous ways that let you test using relative tolerance (`$rel-tol`) or absolute tolerance (`$abs-tol`) of different values.

If no tolerance is set, the function will base the tolerance on the *absolute* value of `$expected`: if it's smaller than `1e-6`, use absolute tolerance of `1e-5`; if it's larger, use relative tolerance of `1e-6`.

```raku
my Numeric ($value, $expected, $abs-tol, $rel-tol) = ...

is-approx $value, $expected;
is-approx $value, $expected, 'test description';

is-approx $value, $expected, $abs-tol;
is-approx $value, $expected, $abs-tol, 'test description';

is-approx $value, $expected, :$rel-tol;
is-approx $value, $expected, :$rel-tol, 'test description';

is-approx $value, $expected, :$abs-tol;
is-approx $value, $expected, :$abs-tol, 'test description';

is-approx $value, $expected, :$abs-tol, :$rel-tol;
is-approx $value, $expected, :$abs-tol, :$rel-tol, 'test description';

```

### [Absolute tolerance](#module_Test "go to top of document")[§](#Absolute_tolerance "direct link")

When an absolute tolerance is set, it's used as the actual maximum value by which the first and the second parameters can differ. For example:

```raku
is-approx 3, 4, 2; # success
is-approx 3, 6, 2; # fail

is-approx 300, 302, 2; # success
is-approx 300, 400, 2; # fail
is-approx 300, 600, 2; # fail

```

Regardless of values given, the difference between them cannot be more than `2`.

### [Relative tolerance](#module_Test "go to top of document")[§](#Relative_tolerance "direct link")

When a relative tolerance is set, the test checks the relative difference between values. Given the same tolerance, the larger the numbers given, the larger the value they can differ by can be.

For example:

```raku
is-approx 10, 10.5, :rel-tol<0.1>; # success
is-approx 10, 11.5, :rel-tol<0.1>; # fail

is-approx 100, 105, :rel-tol<0.1>; # success
is-approx 100, 115, :rel-tol<0.1>; # fail

```

Both versions use `0.1` for relative tolerance, yet the first can differ by about `1` while the second can differ by about `10`. The function used to calculate the difference is:

｢text｣ without highlighting

```

```

              |value - expected|
rel-diff = ────────────────────────
           max(|value|, |expected|)

```

```

and the test will fail if `rel-diff` is higher than `$rel-tol`.

### [Both absolute and relative tolerance specified](#module_Test "go to top of document")[§](#Both_absolute_and_relative_tolerance_specified "direct link")

```raku
is-approx $value, $expected, :rel-tol<.5>, :abs-tol<10>;

```

When both absolute and relative tolerances are specified, each will be tested independently, and the `is-approx` test will succeed only if both pass.

## [sub is-approx-calculate](#module_Test "go to top of document")[§](#sub_is-approx-calculate "direct link")

```raku
sub is-approx-calculate($got, $expected, $abs-tol where { !.defined or $_ >= 0 },
                        $rel-tol where { !.defined or $_ >= 0 }, $desc)

```

This is the actual routine called by [`is-approx` when absolute and relative tolerance are specified](/type/Test#Both_absolute_and_relative_tolerance_specified). They are tested independently, and the test succeeds only if both pass.

## [sub is-deeply](#module_Test "go to top of document")[§](#sub_is-deeply "direct link")

```raku
multi is-deeply(Seq:D $got, Seq:D $expected, $reason = '')
multi is-deeply(Seq:D $got, Mu $expected, $reason = '')
multi is-deeply(Mu $got, Seq:D $expected, $reason = '')
multi is-deeply(Mu $got, Mu $expected, $reason = '')
```

Marks a test as passed if the first and second parameters are equivalent, using the same semantics as the [eqv operator](/routine/eqv). This is the best way to check for equality of (deep) data structures. The function accepts an optional description of the test as the last argument.

```raku
use Test;
plan 1;

sub string-info(Str() $_) {
    Map.new: (
      length  =>  .chars,
      char-counts => Bag.new-from-pairs: (
          letters => +.comb(/<:letter>/),
          digits  => +.comb(/<:digit>/),
          other   => +.comb(/<.-:letter-:digit>/),
    ))
}

is-deeply string-info('42 Butterflies ♥ Raku'), Map.new((
    :21length,
    char-counts => Bag.new-from-pairs: ( :15letters, :2digits, :4other, )
)), 'string-info gives right info';

```

**Note:** for [historical reasons](https://github.com/rakudo/rakudo/commit/096bc17cd5), [`Seq`](/type/Seq)`:D` arguments to `is-deeply` get converted to [`List`](/type/List)s by calling [`.cache`](/routine/cache) on them. If you want to ensure strict [`Seq`](/type/Seq) comparisons, use [`cmp-ok $got, 'eqv', $expected, $desc`](/language/testing#By_arbitrary_comparison) instead.

## [sub cmp-ok](#module_Test "go to top of document")[§](#sub_cmp-ok "direct link")

```raku
multi cmp-ok(Mu $got is raw, $op, Mu $expected is raw, $desc = '')
```

Compares `$got` and `$expected` with the given `$op` comparator and passes the test if the comparison yields a `True` value. The description of the test is optional.

The `$op` comparator can be either a [`Callable`](/type/Callable) or a [`Str`](/type/Str) containing an infix operator, such as `'=='`, a `'~~'`, or a user-defined infix.

```raku
cmp-ok 'my spelling is apperling', '~~', /perl/, "bad speller";

```

Metaoperators cannot be given as a string; pass them as a [`Callable`](/type/Callable) instead:

```raku
cmp-ok <a b c>, &[!eqv], <b d e>, 'not equal';

```

A [`Callable`](/type/Callable) `$op` lets you use custom comparisons:

```raku
sub my-comp { $^a / $^b  < rand };
cmp-ok 1, &my-comp, 2, 'the dice giveth and the dice taketh away'
cmp-ok 2, -> $a, $b { $a.is-prime and $b.is-prime and $a < $b }, 7,
    'we got primes, one larger than the other!';

```

## [sub isa-ok](#module_Test "go to top of document")[§](#sub_isa-ok "direct link")

```raku
multi isa-ok(Mu $var, Mu $type, $desc = "The object is-a '$type.raku()'")
```

Marks a test as passed if the given object `$var` is, or inherits from, the given `$type`. For convenience, types may also be specified as a string. The function accepts an optional description of the test, which defaults to a string that describes the object.

```raku
class Womble {}
class GreatUncleBulgaria is Womble {}
my $womble = GreatUncleBulgaria.new;

isa-ok $womble, Womble, "Great Uncle Bulgaria is a womble";
isa-ok $womble, 'Womble';     # equivalent

```

Note that, unlike `isa`, `isa-ok` also matches `Roles`:

```raku
say 42.isa(Numeric); # OUTPUT: «False␤»
isa-ok 42, Numeric;  # OUTPUT: «ok 1 - The object is-a 'Numeric'␤»

```

## [sub can-ok](#module_Test "go to top of document")[§](#sub_can-ok "direct link")

```raku
multi can-ok(Mu $var, Str $meth, $desc = "..." )
```

Marks a test as passed if the given `$var` can run the method named `$meth`. The function accepts an optional description. For instance:

```raku
class Womble {
    method collect-rubbish { ... }
}
my $womble = Womble.new;

# with automatically generated test description
can-ok $womble, 'collect-rubbish';
#  => An object of type 'Womble' can do the method 'collect-rubbish'

# with human-generated test description
can-ok $womble, 'collect-rubbish', "Wombles can collect rubbish";
#  => Wombles can collect rubbish

```

## [sub does-ok](#module_Test "go to top of document")[§](#sub_does-ok "direct link")

```raku
multi does-ok(Mu $var, Mu $type, $desc = "...")
```

Marks a test as passed if the given `$var` can do the given role `$type`. The function accepts an optional description of the test.

```raku
# create a Womble who can invent
role Invent {
    method brainstorm { say "Aha!" }
}
class Womble {}
class Tobermory is Womble does Invent {}

# ... and later in the tests
use Test;

my $tobermory = Tobermory.new;

# with automatically generated test description
does-ok $tobermory, Invent;
#  => The object does role Type

does-ok $tobermory, Invent, "Tobermory can invent";
#  => Tobermory can invent

```

## [sub like](#module_Test "go to top of document")[§](#sub_like "direct link")

```raku
sub like(Str() $got, Regex:D $expected, $desc = "text matches $expected.raku()")
```

Use it this way:

```raku
like 'foo', /fo/, 'foo looks like fo';

```

Marks a test as passed if the first parameter, when coerced to a string, matches the regular expression specified as the second parameter. The function accepts an optional description of the test with a default value printing the expected match.

## [sub unlike](#module_Test "go to top of document")[§](#sub_unlike "direct link")

```raku
multi unlike(Str() $got, Regex:D $expected, $desc = "text does not match $expected.raku()")
```

Used this way:

```raku
unlike 'foo', /bar/, 'foo does not look like bar';

```

Marks a test as passed if the first parameter, when coerced to a string, does **not** match the regular expression specified as the second parameter. The function accepts an optional description of the test, which defaults to printing the text that did not match.

## [sub use-ok](#module_Test "go to top of document")[§](#sub_use-ok "direct link")

```raku
multi use-ok(Str $code, $desc = "$code module can be use-d ok")
```

Marks a test as passed if the given `$module` loads correctly.

```raku
use-ok 'Full::Qualified::ModuleName';

```

Since `$code` is being turned into an `EVAL`, you can also pass arguments:

```raku
use-ok 'Full::Qualified::ModuleName :my-argument';

```

## [sub dies-ok](#module_Test "go to top of document")[§](#sub_dies-ok "direct link")

```raku
multi dies-ok(Callable $code, $reason = '')
```

Marks a test as passed if the given `$code` throws an [`Exception`](/type/Exception).

The function accepts an optional description of the test.

```raku
sub saruman(Bool :$ents-destroy-isengard) {
    die "Killed by Wormtongue" if $ents-destroy-isengard;
}

dies-ok { saruman(ents-destroy-isengard => True) }, "Saruman dies";

```

## [sub lives-ok](#module_Test "go to top of document")[§](#sub_lives-ok "direct link")

```raku
multi lives-ok(Callable $code, $reason = '')
```

Marks a test as passed if the given `$code` **does not** throw an exception.

The function accepts an optional description of the test.

```raku
sub frodo(Bool :$destroys-ring) {
    die "Oops, that wasn't supposed to happen" unless $destroys-ring;
}

lives-ok { frodo(destroys-ring => True) }, "Frodo survives";

```

## [sub eval-dies-ok](#module_Test "go to top of document")[§](#sub_eval-dies-ok "direct link")

```raku
multi eval-dies-ok(Str $code, $reason = '')
```

Marks a test as passed if the given `$string` throws an [`Exception`](/type/Exception) when `eval`ed as code.

The function accepts an optional description of the test.

```raku
eval-dies-ok q[my $joffrey = "nasty";
               die "bye bye Ned" if $joffrey ~~ /nasty/],
    "Ned Stark dies";

```

## [sub eval-lives-ok](#module_Test "go to top of document")[§](#sub_eval-lives-ok "direct link")

```raku
multi eval-lives-ok(Str $code, $reason = '')
```

Marks a test as passed if the given `$string` **does not** throw an exception when `eval`ed as code.

The function accepts an optional description of the test.

```raku
eval-lives-ok q[my $daenerys-burns = False;
                die "Oops, Khaleesi now ashes" if $daenerys-burns],
    "Dany is blood of the dragon";

```

## [sub throws-like](#module_Test "go to top of document")[§](#sub_throws-like "direct link")

```raku
sub throws-like($code, $ex_type, $reason?, *%matcher)
```

Marks a test as passed if the given `$code` throws the specific exception expected exception type `$ex_type`. The code `$code` may be specified as something [`Callable`](/type/Callable) or as a string to be `EVAL`ed. The exception is specified as a type object.

If an exception was thrown, it will also try to match the matcher hash, where the key is the name of the method to be called on the exception, and the value is the value it should have to pass. For example:

```raku
sub frodo(Bool :$destroys-ring) {
    fail "Oops. Frodo dies" unless $destroys-ring
};
throws-like { frodo }, Exception, message => /dies/;

```

The function accepts an optional description of the test as the third positional argument.

The routine makes [`Failure`](/type/Failure)s fatal. If you wish to avoid that, use [`no fatal` pragma](/language/pragmas#fatal) and ensure the tested code does not sink the possible [`Failure`](/type/Failure)s. If you wish to test that the code returns a [`Failure`](/type/Failure) instead of throwing, use `fails-like` routine instead.

```raku
sub fails-not-throws { +"a" }
# test passes, even though it's just a Failure and would not always throw:
throws-like { fails-not-throws }, Exception;

# test detects nothing thrown, because our Failure wasn't sunk or made fatal:
throws-like { no fatal; my $ = fails-not-throws; Nil }, Exception;

```

Please note that you can only use the string form (for `EVAL`) if you are not referencing any symbols in the surrounding scope. If you are, you should encapsulate your string with a block and an EVAL instead. For instance:

```raku
throws-like { EVAL q[ fac("foo") ] }, X::TypeCheck::Argument;

```

## [sub fails-like](#module_Test "go to top of document")[§](#sub_fails-like "direct link")

```raku
sub fails-like ( \test where Callable:D|Str:D, $ex-type, $reason?, *%matcher)
```

Same interface as `throws-like`, except checks that the code returns a [`Failure`](/type/Failure) instead of throwing. If the code does throw or if the returned [`Failure`](/type/Failure) has already been [handled](/routine/handled), that will be considered as a failed test.

```raku
fails-like { +"a" }, X::Str::Numeric,
    :message(/'Cannot convert string to number'/),
    'converting non-numeric string to number fails';

```

## [sub subtest](#module_Test "go to top of document")[§](#sub_subtest "direct link")

```raku
multi subtest(Pair $what)
multi subtest($desc, &subtests)
multi subtest(&subtests, $desc = '')
```

The `subtest` function executes the given block, consisting of usually more than one test, possibly including a `plan` or `done-testing`, and counts as *one* test in `plan`, `todo`, or `skip` counts. It will pass the test only if **all** tests in the block pass. The function accepts an optional description of the subtest.

```raku
class Womble {}

class GreatUncleBulgaria is Womble {
    has $.location = "Wimbledon Common";
    has $.spectacles = True;
}

subtest {
    my $womble = GreatUncleBulgaria.new;

    isa-ok $womble,            Womble,             "Correct type";
    is     $womble.location,   "Wimbledon Common", "Correct location";
    ok     $womble.spectacles,                     "Correct eyewear";

}, "Check Great Uncle Bulgaria";

```

You can also place the description as the first positional argument, or use a [`Pair`](/type/Pair) with description as the key and subtest's code as the value. This can be useful for subtests with large bodies.

```raku
subtest 'A bunch of tests', {
    plan 42;
    ...
    ...
}

subtest 'Another bunch of tests' => {
    plan 72;
    ...
    ...
}

```

## [sub todo](#module_Test "go to top of document")[§](#sub_todo "direct link")

```raku
multi todo($reason, $count = 1)
```

Sometimes tests just aren't ready to be run, for instance a feature might not yet be implemented, in which case tests can be marked as `todo`. Or it could be the case that a given feature only works on a particular platform - in which case one would `skip` the test on other platforms.

Mark `$count` tests as TODO, giving a `$reason` as to why. By default only one test will be marked TODO.

```raku
sub my-custom-pi { 3 };

todo 'not yet precise enough';         # Mark the test as TODO.
is my-custom-pi(), pi, 'my-custom-pi'; # Run the test, but don't report
                                       # failure in test harness.

```

The result from the test code above will be something like:

｢TAP｣ without highlighting

```

```

not ok 1 - my-custom-pi # TODO not yet precise enough
# Failed test 'my-custom-pi'
# at test-todo.rakutest line 7
# expected: '3.14159265358979'
#      got: '3'

```

```

Note that if you `todo` a `subtest`, all of the failing tests inside of it will be automatically marked TODO as well and will *not* count towards your original TODO count.

## [sub skip](#module_Test "go to top of document")[§](#sub_skip "direct link")

```raku
multi skip()
multi skip($reason, $count = 1)
```

Skip `$count` tests, giving a `$reason` as to why. By default only one test will be skipped. Use such functionality when a test (or tests) would die if run.

```raku
sub num-forward-slashes($arg) { ... } ;

if $*KERNEL ~~ 'linux' {
    is num-forward-slashes("/a/b"),             2;
    is num-forward-slashes("/a//b".IO.cleanup), 2;
}
else {
    skip "Can't use forward slashes on Windows", 2;
}

```

Note that if you mark a test as skipped, you must also prevent that test from running.

## [sub skip-rest](#module_Test "go to top of document")[§](#sub_skip-rest "direct link")

```raku
sub skip-rest($reason = '<unknown>')
```

Skip the remaining tests. If the remainder of the tests in the test file would all fail due to some condition, use this function to skip them, providing an optional `$reason` as to why.

```raku
my $location; sub womble { ... }; ...;
unless $location ~~ "Wimbledon Common" {
    skip-rest "We can't womble, the remaining tests will fail";
    exit;
}

# tests requiring functional wombling
ok womble();
# ...

```

Note that `skip-rest` requires a `plan` to be set, otherwise the `skip-rest` call will throw an error. Note that `skip-rest` does not exit the test run. Do it manually, or use conditionals to avoid running any further tests.

See also [`plan :skip-all('...')`](#sub_plan) to avoid running any tests at all and [`bail-out`](#sub_bail-out) to abort the test run and mark it as failed.

## [sub bail-out](#module_Test "go to top of document")[§](#sub_bail-out "direct link")

```raku
sub bail-out ($desc?)
```

If you already know the tests will fail, you can bail out of the test run using `bail-out()`:

```raku
my $has-db-connection;
...
$has-db-connection  or bail-out 'Must have database connection for testing';

```

The function aborts the current test run, signaling failure to the harness. Takes an optional reason for bailing out. The subroutine will call `exit()`, so if you need to do a clean-up, do it before calling `bail-out()`.

If you want to abort the test run, but without marking it as failed, see [`skip-rest`](#sub_skip-rest) or [`plan :skip-all('...')`](#sub_plan)

## [sub pass](#module_Test "go to top of document")[§](#sub_pass "direct link")

```raku
multi pass($desc = '')
```

The `pass` function marks a test as passed. `flunk` marks a test as **not** passed. Both functions accept an optional test description.

```raku
pass "Actually, this test has passed";
flunk "But this one hasn't passed";

```

Since these subroutines do not provide indication of what value was received and what was expected, they should be used sparingly, such as when evaluating a complex test condition.

## [sub flunk](#module_Test "go to top of document")[§](#sub_flunk "direct link")

```raku
multi flunk($reason = '')
```

The opposite of `pass`, makes a test fail with an optional message.

## [sub diag](#module_Test "go to top of document")[§](#sub_diag "direct link")

```raku
sub diag($message)
```

Display diagnostic information in a TAP-compatible manner on the standard error stream. This is usually used when a particular test has failed to provide information that the test itself did not provide. Or it can be used to provide visual markers on how the testing of a test-file is progressing (which can be important when doing stress testing).

```raku
diag "Yay!  The tests got to here!";

```

# [Typegraph](# "go to top of document")[§](#typegraphrelations "direct link")

Type relations for `Test`

raku-type-graph

Test
Test

Any
Any

Test->Any

Mu
Mu

Any->Mu

[Expand chart above](/assets/typegraphs/Test.svg)


## dist_zef-raku-community-modules-SCGI.md
[![Actions Status](https://github.com/raku-community-modules/SCGI/actions/workflows/test.yml/badge.svg)](https://github.com/raku-community-modules/SCGI/actions)

# NAME

SCGI - A SCGI library for Raku

# DESCRIPTION

This is a simple SCGI library for Raku.

It's main influences are the Perl SCGI library, and the Raku HTTP::Daemon library.

It offers a bit of candy coating compared to the Perl version.

By default is uses a PSGI-compliant interface, but can also handle raw HTTP responses.

You don't need to create your own `IO::Socket::INET` object. Just pass an 'addr' and 'port' attribute to the new() declaration and it'll create the object for you.

# USAGE

The simplest (and recommended) form of usage is to use the handle() method with PSGI-compliant output. Here's an example:

```
use SCGI;

my $scgi = SCGI.new( :port(8118) );

sub handler(%env) {
    my $name    = %env<QUERY_STRING> || 'world';
    my $status  = '200';
    my @headers = 'Content-Type' => 'text/plain';
    my @body    = "Hello $name\n";
    @headers.push: 'Content-Length' => @body.join.encode.bytes;
    [ $status, @headers, @body ]
}

$scgi.handle: &handler;

```

There are other ways of using SCGI, such as writing your own run loop, or using a raw HTTP output instead of PSGI. Here's an example doing both:

```
use SCGI;

my $scgi = SCGI.new( :port(8118), :!PSGI, :!P6SGI );
while my $connection = $scgi.accept() {
    my $request = $connection.request;
    if $request.success {
        my $name    = $request.env<QUERY_STRING> || 'world';
        my $return  = "Hello $name\n";
        my $len     = $return.encode.bytes;
        my $headers = "Content-Type: text/plain\nContent-Length: $len\n";
        $connection.send("$headers\n$return");
    }
    $connection.close;
}

```

Test script representing both examples can be found in the 'examples' folder.

If you are serious about using SCGI for web application development, see the [Web](https://github.com/raku-community-modules/Web/) library set, or one of the full blown frameworks built using it.

# CONFIGURATION

## nginx

Make sure you compiled nginx with the SCGI plugin (it is included by default.) Then, in one of your server blocks, add a location mount:

```
location /scgi/ {
    scgi_pass 127.0.0.1:8118;
    include scgi_params;
    # Optionally rewrite document URI path
    rewrite ^/scgi/(.*) /$1 break;
    # Some applications may need rewritten URI in PATH_INFO
    scgi_param PATH_INFO $uri;
}

```

## lighttpd

First, make sure the SCGI library is being loaded.

```
server.modules += ( "mod_scgi" )

```

Next, set up an SCGI handler:

```
scgi.server = (
    "/scgi" =>
    ((
      "host" => "127.0.0.1",
      "port" => 8118,
      "check-local" => "disable"
    ))
)

```

## Apache 2 with mod\_scgi:

Add the following line to your site config, changing the details to match your SCGI script configuration:

```
SCGIMount /scgi/ 127.0.0.1:8118

```

## Apache 2 with mod\_proxy\_scgi:

Add the following line to your site config, changes the details to match your SCGI script configuration:

```
<Proxy *>
    Order deny,allow
    Allow from all
</Proxy>
ProxyPass /scgi/ scgi://localhost:8118/

```

# AUTHOR

Timothy Totten

# COPYRIGHT AND LICENSE

Copyright 2013 - 2017 Timothy Totten

Copyright 2018 - 2022 Raku Community

This library is free software; you can redistribute it and/or modify it under the Artistic License 2.0.


## trim.md
trim

Combined from primary sources listed below.

# [In Allomorph](#___top "go to top of document")[§](#(Allomorph)_method_trim "direct link")

See primary documentation
[in context](/type/Allomorph#method_trim)
for **method trim**.

```raku
method trim(Allomorph:D:)
```

Calls [`Str.trim`](/type/Str#method_trim) on the invocant's [`Str`](/type/Str) value.

# [In Str](#___top "go to top of document")[§](#(Str)_method_trim "direct link")

See primary documentation
[in context](/type/Str#method_trim)
for **method trim**.

```raku
method trim(Str:D: --> Str)
```

Remove leading and trailing whitespace. It can be used both as a method on strings and as a function. When used as a method it will return the trimmed string. In order to do in-place trimming, one needs to write `.=trim`

```raku
my $line = '   hello world    ';
say '<' ~ $line.trim ~ '>';        # OUTPUT: «<hello world>␤»
say '<' ~ trim($line) ~ '>';       # OUTPUT: «<hello world>␤»
$line.trim;
say '<' ~ $line ~ '>';             # OUTPUT: «<   hello world    >␤»
$line.=trim;
say '<' ~ $line ~ '>';             # OUTPUT: «<hello world>␤»
```

See also [trim-trailing](/routine/trim-trailing) and [trim-leading](/routine/trim-leading).

# [In Cool](#___top "go to top of document")[§](#(Cool)_routine_trim "direct link")

See primary documentation
[in context](/type/Cool#routine_trim)
for **routine trim**.

```raku
sub trim(Str(Cool))
method trim()
```

Coerces the invocant (or in sub form, its argument) to [`Str`](/type/Str), and returns the string with both leading and trailing whitespace stripped.

```raku
my $stripped = '  abc '.trim;
say "<$stripped>";          # OUTPUT: «<abc>␤»
```


## dist_zef-lizmat-Array-Sorted-Map.md
[![Actions Status](https://github.com/lizmat/Array-Sorted-Map/actions/workflows/linux.yml/badge.svg)](https://github.com/lizmat/Array-Sorted-Map/actions) [![Actions Status](https://github.com/lizmat/Array-Sorted-Map/actions/workflows/macos.yml/badge.svg)](https://github.com/lizmat/Array-Sorted-Map/actions) [![Actions Status](https://github.com/lizmat/Array-Sorted-Map/actions/workflows/windows.yml/badge.svg)](https://github.com/lizmat/Array-Sorted-Map/actions)

# NAME

Array::Sorted::Map - Provide a Map interface for 2 sorted lists

# SYNOPSIS

```
use Array::Sorted::Util;
use Array::Sorted::Map;

my @keys;
my @values;

inserts(@keys, "a", @values, 42);  # "inserts" from Array::Sorted::Util
inserts(@keys, "b", @values, 666);

my %map := Array::Sorted::Map.new(:$keys, :$values);

say %map<a>;  # 42;
say %map<b>;  # 666;
say %map<c>;  # Nil

say %map.keys;    # (a b)
say %map.values;  # (42 666)

```

# DESCRIPTION

Array::Sorted::Map provides a class that can be used to provide a `Map` interface to two sorted lists: one for keys, and one for values, such as typically created / maintained by the subroutines offered by the `Array::Sorted::Util` distribution.

Optionally, a `:cmp` argument can be specified, indicating the logic that should be used for comparing elements from the keys. By default, the `infix:<cmp>` will be assumed.

# AUTHOR

Elizabeth Mattijsen [liz@raku.rocks](mailto:liz@raku.rocks)

Source can be located at: <https://github.com/lizmat/Array-Sorted-Map> . Comments and Pull Requests are welcome.

If you like this module, or what I’m doing more generally, committing to a [small sponsorship](https://github.com/sponsors/lizmat/) would mean a great deal to me!

# COPYRIGHT AND LICENSE

Copyright 2021, 2024, 2025 Elizabeth Mattijsen

This library is free software; you can redistribute it and/or modify it under the Artistic License 2.0.


## dist_zef-lizmat-Text-Flags.md
[![Actions Status](https://github.com/lizmat/Text-Flags/actions/workflows/linux.yml/badge.svg)](https://github.com/lizmat/Text-Flags/actions) [![Actions Status](https://github.com/lizmat/Text-Flags/actions/workflows/macos.yml/badge.svg)](https://github.com/lizmat/Text-Flags/actions) [![Actions Status](https://github.com/lizmat/Text-Flags/actions/workflows/windows.yml/badge.svg)](https://github.com/lizmat/Text-Flags/actions)

# NAME

Text::Flags - easy interface to Unicode flags

# SYNOPSIS

```
use Text::Flags;

say "This is the flag of %regions<NL>: %flags<NL>"

```

# DESCRIPTION

Text::Flags provides an easy interface to the Unicode codepoints that render as flags, and their associated regions and names.

It also contains a command-line interface `tf` that either takes any number of flag identifiers (e.g. `tf chequered` will show 🏁). This also takes an optional `--list` argument to show all supported flags, and a `--verbose` argument to show additional information about the indicated flag(s).

# EXPORTED HASHES

## %flags

```
say %flags<chequered>;   # 🏁

```

The `%flags` hash contains the mapping of country / region codes and some special flags, to their associated Unicode representations. Please note that some flags, or possibly all flags, may not render correctly on your platform, even if they are valid Unicode representations. Keys can be specified in either uppercase or lowercase.

You can use the `.keys` method to find out which flags are supported. Please note that only lowercase keys will be returned.

Note that flags of deprecated countries / regions **may** consist of a junction of possible renderings.

## %regions

```
say %regions<NL>;   # The Netherlands

```

The `%regions` hash contains the mapping of country / region codes to their associated name. Keys can be specified in either uppercase or lowercase.

You can use the `.keys` method to find out which regions are supported. Please note that only lowercase keys will be returned.

## %deprecated

```
say %deprecated<BU>;   # Burma

```

The `%deprecated` hash contains the mapping of deprecated country / region codes to their associated name. Keys can be specified in either uppercase or lowercase.

You can use the `.keys` method to find out which deprecations are known. Please note that only lowercase keys will be returned.

# EXPORTED SUBROUTINES

## ric

```
say ric("NL").uninames;  # (REGIONAL INDICATOR SYMBOL LETTER N REGIONAL INDICATOR SYMBOL LETTER L)

```

The `ric` subroutine performs a Regional Indicator case conversion on a given string. Any letter (either lowercase or uppercase) is converted to its associated Regional Indicator version, e.g. "a" (also known as "LATIN SMALL LETTER A") is converted to "REGIONAL INDICATOR SYMBOL LETTER A".

This is primarily intended as a helper subroutine, but may have other uses outside of this module.

# SUPPORTED FLAGS

```
ac ad ae af ag ai al am ao aq ar as at au aw ax az
ba bb bd be bf bg bh bi bj bl bm bn bo bq br bs bt bv bw by bz
ca cc cd cf cg ch ci ck cl cm cn co cp cr cu cv cw cx cy cz
de dg dj dk dm do dz
ea ec ee eg eh er es et eu
fi fj fk fm fo fr
ga gb gd ge gf gg gh gi gl gm gn gp gq gr gs gt gu gw gy
hk hm hn hr ht hu
ic id ie il im in io iq ir is it
je jm jo jp
ke kg kh ki km kn kp kr kw ky kz
la lb lc li lk lr ls lt lu lv ly
ma mc md me mf mg mh mk ml mm mn mo mp mq mr ms mt mu mv mw mx my mz
na nc ne nf ng ni nl no np nr nu nz
om
pa pe pf pg ph pk pl pm pn pr ps pt pw py
qa
re ro rs ru rw
sa sb sc sd se sg sh si sj sk sl sm sn so sr ss st sv sx sy sz
ta tc td tf tg th tj tk tl tm tn to tr tt tv tw tz
ua ug um un us uy uz
va vc ve vg vi vn vu
wf ws xk
ye yt
za zm zw

an bu cs dd fx nt qu su tp yd yu zr

england scotland wales

california texas

black chequered crossed pirate rainbow transgender triangular white

```

# AUTHOR

Elizabeth Mattijsen [liz@raku.rocks](mailto:liz@raku.rocks)

Source can be located at: <https://github.com/lizmat/Text-Flags> . Comments and Pull Requests are welcome.

If you like this module, or what I'm doing more generally, committing to a [small sponsorship](https://github.com/sponsors/lizmat/) would mean a great deal to me!

# COPYRIGHT AND LICENSE

Copyright 2020, 2021, 2024 Elizabeth Mattijsen

This library is free software; you can redistribute it and/or modify it under the Artistic License 2.0.


## dist_zef-tbrowder-DateTime-Julian.md
[![Actions Status](https://github.com/tbrowder/DateTime-Julian/actions/workflows/linux.yml/badge.svg)](https://github.com/tbrowder/DateTime-Julian/actions) [![Actions Status](https://github.com/tbrowder/DateTime-Julian/actions/workflows/macos.yml/badge.svg)](https://github.com/tbrowder/DateTime-Julian/actions) [![Actions Status](https://github.com/tbrowder/DateTime-Julian/actions/workflows/windows.yml/badge.svg)](https://github.com/tbrowder/DateTime-Julian/actions)

# DateTime::Julian

Provides a DateTime::Julian class (a subclass of Raku's class **DateTime**) that is instantiated by either a Julian Date (JD) or a Modified Julian Date (MJD) (or any of the DateTime instantiation methods).

It also provides addional time data not provided by the core class.

# SYNOPSIS

```
use DateTime::Julian :ALL; # export all constants

my $jd   = nnnn.nnnn; # Julian Date for some event
my $mjd  = nnnn.nnnn; # Modified Julian Date for some event
my $utc  = DateTime::Julian.new: :julian-date($jd);
my $utc2 = DateTime::Julian.new: :modified-julian-date($mjd);
my $d    = DateTime::Julian.now; # the default

```

# DESCRIPTION

Module **DateTime::Julian** defines a class (inherited from a Raku *DateTime* class) that is instantiated from a *Julian Date* or a *Modified Julian Date*.

Following are some pertinent definitions from Wikipedia topic [*Julian day*](https://en.m.wikipedia.org/wiki/Julian_day):

* The **Julian day** is the continuous count of the days since the beginning of the Julian period, and is used primarily by astronomers....
* The **Julian day number** (JDN) is the integer assigned to a whole solar day count starting from noon Universal time, with Julian day number 0 assigned to the day starting at noon on Monday, January 1, 4713 BC, proleptic [Note 1] Julian calendar (November 24, 4714 BC, in the proleptic Gregorian calendar), a date at which three multi-year cycles started (which are: indiction, Solar, and Lunar cycles) and which preceded any dates in recorded history. For example, the Julian day number for the day starting at 12:00 UT (noon) on January 1, 2000, was **2451545**.
* The **Julian date** (JD) of any instant is the Julian day number plus the fraction of a day since the preceding noon in Universal Time. Julian dates are expressed as a Julian day number with a decimal fraction added. For example, the Julian date for 00:30:00.0 UT (noon), January 1, 2013, is **2456293.520833**.

The following methods and routines were developed from the descriptions of code in [References 1 and 2](#References). The author of Ref. 3 has been very helpful with this author's questions about astronomy and the implementation of astronomical routines.

The main purpose of this module is to simplify time and handling for this author who still finds Julian dates to be somewhat mysterious, but absolutely necessary for dealing with astronomy and predicting object positions, especially the Sun and Moon, for local observation and producing astronomical almanacs.

This module plays a major supporting role in this author's Raku module **Astro::Almanac**. Much of this module's will likely be incorporated into that module..

## Class DateTime::Julian methods

### method new

```
new(:$julian-date, :$modified-julian-date) {...}

```

If both arguments are entered, the *Julian Date* is used. If neither is entered, the user is expected to use one of the normal **DateTime** creation methods. For example:

```
my $d = DateTime.now;
# the Julian Date returned is the current JD at the Prime
# Meridian (0 degrees longitude) based on the current local time
# (:timezone is ignored)
say $d.julian-date; # OUTPUT: «2460819.8055783305␤»

```

### method jdcent2000

```
jdcent2000(--> Real:D) {...}
# alternatively use aliases:
method cent2000(--> Real:D)  {...}
method c2000(--> Real:D)     {...}
method jdc2000(--> Real:D)   {...}
method t2000(--> Real:D)     {...}
method jc2000(--> Real:D)    {...}

```

Returns time as the number of Julian centuries since epoch J2000.0 (time value used by Astro::Montenbruck for planet position calculations).

## Exported constants

Several commonly used astronautical constants are exported. See a complete list in [CONSTANTS](CONSTANTS.md) along with each constants' individual export tag. You may export them all with `use DateTime::Julian :ALL;`.

### MJD0

Returns the Julian Date value for the Modified Julian Date epoch of 1858-11-17T00:00:00Z.

```
use DateTime::Julian :ALL;
say MJD0;               # OUTPUT: «2400000.5␤»
# alternatively use aliases:
say mjd0;               # OUTPUT: «2400000.5␤»

```

### POSIX0

Returns the Julian Date value for the POSIX (Unix) epoch of 1970-01-01T00:00:00Z.

```
say POSIX0;               # OUTPUT: «2440587.5␤»
# alternatively use alias:
say posix0;               # OUTPUT: «2440587.5␤»

```

### JCE

The last day the Julian calendar was used. A DateTime object for 1582-10-04T00:00:00Z.

```
say JCE;                 # OUTPUT: «1582-10-04T00:00:00Z␤»
# alternatively use alias:
say jce;                 # OUTPUT: «1582-10-04T00:00:00Z␤»

```

### GC0

The official start date for the Gregorian calendar. A DateTime object for 1582-1014T00:00:00Z. The days of 5-14 were skipped (the 10 "lost days").

```
say GC0;                 # OUTPUT: «1582-10-15T00:00:00Z␤»
# alternatively use alias:
say gc0;                 # OUTPUT: «1582-10-15T00:00:00Z␤»

```

### J2000

Julian date for 2000-01-01T12:00:00Z (astronomical epoch 2000.0).

```
say J2000;               # OUTPUT: «2451545␤»
# alternatively use alias:
say j2000;               # OUTPUT: «2451545␤»

```

### J1900

Julian date for 1899-12-31T12:00:00Z (astronomical epoch 1900.0).

```
say J1900;               # OUTPUT: «2415020␤»
# alternatively use alias:
say j1900;               # OUTPUT: «2415020␤»

```

### sec-per-day

Seconds per 24-hour day.

```
say sec-per-day;         # OUTPUT: «86400␤»

```

### sec-per-jcen

Seconds per Julian century.

```
say sec-per-jcen;        # OUTPUT: «3155760000␤»

```

### days-per-jcen

Days per Julian century.

```
say days-per-jcen;       # OUTPUT: «36525␤»

```

### solar2sidereal

Difference between Sidereal and Solar hour (the former is shorter).

```
say solar2sidereal;      # OUTPUT: «1.002737909350795␤»

```

# To Do

* Add calculations (and tests) for Ephemeris Time and Universal Time. (See Ref. 1, section 3.4, p. 41.)
* Add calculations for local sidereal time

# Notes

1. A *proleptic calendar*, according to Wikipedia, "is a calendar that is applied to dates before its introduction."

# References

1. *Astronomy on the Personal Computer*, Oliver Montenbruck and Thomas Pfleger, Springer, 2000.
2. *Celestial Calculations: A Gentle Introduction to Computational Astronomy*, J. L. Lawrence, The MIT Press, 2019.
3. *Astro::Montenbruck*, Sergey Krushinsky, CPAN.
4. *Mapping Time: The Calendar and Its History*, E. G. Richards, Oxford University Press, 2000.
5. *Date Algorithms* (Version 5), Peter Baum, Aesir Research, 2020, <https://researchgate.net/publication/316558298>.

# See also

* Raku module Astro::Utils

# AUTHOR

Tom Browder ([tbrowder@acm.org](mailto:tbrowder@acm.org))

# COPYRIGHT AND LICENSE

© 2021-2022, 2025 Tom Browder


## role.md
role

Combined from primary sources listed below.

# [In Object orientation](#___top "go to top of document")[§](#(Object_orientation)_role_role "direct link")

See primary documentation
[in context](/language/objects#Roles)
for **Roles**.

Roles are a collection of attributes and methods; however, unlike classes, roles are meant for describing only parts of an object's behavior; this is why, in general, roles are intended to be *mixed in* classes and objects. In general, classes are meant for managing objects and roles are meant for managing behavior and code reuse within objects.

Roles use the keyword `role` preceding the name of the role that is declared. Roles are mixed in using the `does` keyword preceding the name of the role that is mixed in.

Roles can also be mixed into a class using `is`. However, the semantics of `is` with a role are quite different from those offered by `does`. With `is`, a class is punned from the role, and then inherited from. Thus, there is no flattening composition, and none of the safeties which `does` provides.

```raku
constant ⲧ = " " xx 4; #Just a ⲧab
role Notable {
    has Str $.notes is rw;

    multi method notes() { "$!notes\n" };
    multi method notes( Str $note ) { $!notes ~= "$note\n" ~ ⲧ };

}

class Journey does Notable {
    has $.origin;
    has $.destination;
    has @.travelers;

    method Str { "⤷ $!origin\n" ~ ⲧ ~ self.notes() ~ "$!destination ⤶\n" };
}

my $trip = Journey.new( :origin<Here>, :destination<There>,
                        travelers => <þor Freya> );

$trip.notes("First steps");
notes $trip: "Almost there";
print $trip;
# OUTPUT:
#⤷ Here
#       First steps
#       Almost there
#
#There ⤶

```

Roles are immutable as soon as the compiler parses the closing curly brace of the role declaration.

# [In Glossary](#___top "go to top of document")[§](#(Glossary)_role_role "direct link")

See primary documentation
[in context](/language/glossary#Roles)
for **Roles**.

Roles, mix-ins or traits define interfaces and/or implementation of those interfaces as well as instance variables using them, and are mixed-in when declaring classes that follow that interface. [Abstract classes](#Abstract_class) are particular examples of Roles where the actual implementation is deferred to the class that uses that Role.

Roles are part of Raku's [object system](/language/objects), and are declared using the [role](/language/objects#index-entry-role_declaration-role) keyword and used in class declaration via [does](/routine/does).


## dist_zef-jonathanstowe-JSON-Class.md
# JSON::Class

A Role to allow Raku objects to be constructed and serialised from/to JSON.

![Build Status](https://github.com/jonathanstowe/JSON-Class/workflows/CI/badge.svg)

## Synopsis

```

    use JSON::Class;

    class Something does JSON::Class {

        has Str $.foo;

    }

    my Something $something = Something.from-json('{ "foo" : "stuff" }');

    ...

    my Str $json = $something.to-json(); # -> '{ "foo" : "stuff" }'

```

or with 'opt-in' serialization:

```

    use JSON::Class;
    use JSON::OptIn;

    class Something does JSON::Class[:opt-in] {

        has Str $.foo is json;
        has Str $.secret = 'secret';

    }

    my Something $something = Something.from-json('{ "foo" : "stuff" }');

    ...

    my Str $json = $something.to-json(); # -> '{ "foo" : "stuff" }'

```

## Description

This is a simple role that provides methods to instantiate a class from a
JSON string that (hopefully,) represents it, and to serialise an object of
the class to a JSON string. The JSON created from an instance should
round trip to a new instance with the same values for the "public attributes".
"Private" attributes (that is ones without accessors,) will be ignored for
both serialisation and de-serialisation. The exact behaviour depends on that
of [JSON::Marshal](https://github.com/jonathanstowe/JSON-Marshal) and
[JSON::Unmarshal](https://github.com/tadzik/JSON-Unmarshal) respectively.

If the `:skip-null` adverb is provided to `to-json` all attributes
without a defined value will be ignored in serialisation. If you need
finer grained control then you should apply the `json-skip-null`
attribute trait (defined by `JSON::Marshal` ) to the attributes you
want to skip if they aren't defined (`:skip-null` will still have
the same effect though.)

If you don't need prettified, human readable JSON output then you can supply
the `:!pretty` adverb to `to-json`.

The [JSON::Marshal](https://github.com/jonathanstowe/JSON-Marshal) and
[JSON::Unmarshal](https://github.com/tadzik/JSON-Unmarshal) provide traits
for controlling the unmarshalling/marshalling of specific attributes which are
re-exported by the module.

If your application exposes the marshalled data via, for example, an API, then
you may choose to use the `:opt-in` parameter to the role, which will cause only
those attributes that are explicitly marked to be marshalled, avoiding the risk
of inadvertently exposing sensitive data. This is described in more detail in
[JSON::Marshal](https://github.com/jonathanstowe/JSON-Marshal).

## Installation

Assuming you have a working Rakudo installation you should be able to install this with *zef* :

```
# From the source directory

zef install .

# Remote installation

zef install JSON::Class

```

## Support

Suggestions/patches are welcomed via github at:

<https://github.com/jonathanstowe/JSON-Class>

## Licence

This is free software.

Please see the (LICENCE)[LICENCE] file in the distribution for the details.

© Jonathan Stowe 2015, 2016, 2017, 2019, 2020, 2021


## dist_cpan-RBT-Email-MIME.md
# Email::MIME

This is a port of perl 5's Email::MIME.

## Example Usage

```
use Email::MIME;

my $eml = Email::MIME.new($raw-mail-text);
say $eml.body-str;

my $new = Email::MIME.create(header-str => ['from' => 'root+github@retupmoca.com',
                                            'subject' => 'This is a»test.'],
                             attributes => {'content-type' => 'text/plain',
                                            'charset' => 'utf-8',
                                            'encoding' => 'quoted-printable'},
                             body-str => 'Hello«World');
say ~$new;

```

## Faster Base64 Encoding

To benefit from faster Base64 encoding and decoding install the `Base64::Native` module
which will be auto-detected and used automatically.

## Methods

* `new(Str $text)`

  To work around the current limitation of new() requiring a well formed unicode Str, you will
  need to set the correct decoding on Slurp.

  ```
  my $msg = Email::MIME.new($file.IO.slurp: enc => 'utf8-c8');

  ```
* `create(:$header, :$header-str, :$attributes, :$parts, :$body, :$body-str)`
* `filename($force = False)`
* `invent-filename($ct?)`
* `filename-set($filename)`
* `boundary-set($string)`
* `content-type()`
* `content-type-set($ct)`
* `charset-set($charset)`
* `name-set($name)`
* `format-set($format)`
* `disposition-set($disposition)`
* `encoding-set($enc)`
* `parts()`

  Returns the subparts of the current message. If there are no subparts, will
  return the current message.
* `subparts()`

  Returns the subparts of the current message. If there are no subparts, will
  return an empty list.
* `walk-parts($callback)`

  Visits each MIME part once, calling `$callback($part)` on each.
* `debug-structure()`

  Prints out the part structure of the email.
* `parts-set(@parts)`

  Sets the passed `Email::MIME` objects as the parts of the email.
* `parts-add(@parts)`

  Adds the passed `Email::MIME` objects to the list of parts in the email.
* `body-str( --> Str)`

  Returns the mail body, decoded according to the charset and transfer encoding
  headers.
* `body-str-set(Str $body)`

  Sets the mail body to $body, encoding it using the charset and transfer
  encoding configured.
* `body( --> Buf)`

  Returns the mail body as a binary blob, after decoding it from the
  transfer encoding.
* `body-set(Blob $data)`

  Sets the mail body to `$data`. Will encode $data using the configured
  transfer encoding.
* `body-raw()`

  Returns the raw body of the email (What will appear when .Str is called)
* `body-raw-set($body)`

  Sets the raw body of the email (What will appear when .Str is called)
* `header-str-pairs()`

  Returns the full header data for an email.
* `header-str($name, :$multi)`

  Returns the email header with the name `$name`. If `:$multi` is not passed, then
  this will return the first header found. If `:$multi` is set, then this will
  return a list of all headers with the name `$name` (note the change from v1.0!)
* `header-str-set($name, *@lines)`

  Sets the header `$name`. Adds one `$name` header for each additional argument
  passed.
* `header-names()`

  Returns a list of header names in the email.
* `headers()`

  Alias of `header-names()`
* `header($name)`

  Returns a list of email headers with the name `$name`. If used in string context,
  will act like the first value of the list. (So you can call
  `say $eml.header('Subject')` and it will work correctly). Note that this will
  not decode any encoded headers.
* `header-set($name, *@lines)`

  Sets the header `$name`. Adds one `$name` header for each additional argument
  passed. This will not encode any headers, even if they have non-ascii
  characters.
* `header-pairs()`

  Returns the full header data for an email. Note that this will not decode any
  encoded headers.

  ```
  $eml.header-pairs(); # --> [['Subject', 'test'], ['From', 'me@example.com']]

  ```
* `as-string()`, `Str()`

  Returns the full raw email, suitable for piping into sendmail.
* `crlf()`
* `header-obj()`
* `header-obj-set($obj)`

## License

All files in this repository are licensed under the terms of the Creative Commons
CC0 License; for details, please see the LICENSE file


## dist_cpan-JMASLAK-App-Heater.md
[![Build Status](https://travis-ci.org/jmaslak/Raku-App-Heater.svg?branch=master)](https://travis-ci.org/jmaslak/Raku-App-Heater)

# POD

# NAME

`heater.raku` - Raku-based Foot Warmer

# SYNOPSIS

```
heater.raku

```

# DESCRIPTION

This program was written during a period of brutally cold weather, when the author was trying to figure out how to keep her feet warm. Since her computer is on the floor by her feet, and because she knows that the busier the CPU, the more heat generated, she wrote this module to load up the CPU.

# CAVEATS

Obviously your electrical usage footprint (no pun intended) will increase if you run this program. That said, I believe this program is only slightly less efficient to turn your computer into a space heater than an actual space heater of the same wattage would be (I.E. energy used for "useful work" on the computer like sending signals to your monitor or lighting the power LED would not be turned into heat, while an electric space heater has even less of these "housekeeping" functions). In practice, I believe the energy difference to be negligable.

Only use this if your feet are cold!

# USAGE

## ARGUMENTS

### `processes`

```
heater.raku --processes=3

```

Sets the number of "heater" threads to start. This defaults to the number of CPU cores in the machine, determined by `$*KERNEL.cpu-cores`.

# AUTHOR

Joelle Maslak `jmaslak@antelope.net`

# LEGAL

Licensed under the same terms as Raku.

Copyright © 2021 by Joelle Maslak


## gather-20take.md
gather take

Combined from primary sources listed below.

# [In Control flow](#___top "go to top of document")[§](#(Control_flow)_gather_take_gather_take "direct link")

See primary documentation
[in context](/language/control#gather/take)
for **gather/take**.

`gather` is a statement or block prefix that returns a [sequence](/type/Seq) of values. The values come from calls to [take](/type/Mu#routine_take) in the dynamic scope of the `gather` code. In the following example, we implement a subroutine to compute the factors of an integer with `gather` (note that the factors are not generated in order):

```raku
sub factors( Int:D \n ) {
    my $k = 1;
    gather {
        while $k**2 < n {
            if n %% $k {
                take $k;
                take n div $k;
            }
            $k++;
        }
        take $k if $k**2 == n;
    }
}

say factors(36); # OUTPUT: «1, 36, 2, 18, 3, 12, 4, 9, 6␤»
```

The `gather/take` combination can generate values lazily, depending on context. Binding to a scalar or sigilless container will force laziness. If you want to force lazy evaluation use the [lazy](/type/Iterable#method_lazy) subroutine or method. For example:

```raku
my @vals = lazy gather {
    take 1;
    say "Produced a value";
    take 2;
}
say @vals[0];
say 'between consumption of two values';
say @vals[1];

# OUTPUT:
# 1
# between consumption of two values
# Produced a value
# 2
```

`gather/take` is scoped dynamically, so you can call `take` from subs or methods that are called from within `gather`:

```raku
sub weird(@elems, :$direction = 'forward') {
    my %direction = (
        forward  => sub { take $_ for @elems },
        backward => sub { take $_ for @elems.reverse },
        random   => sub { take $_ for @elems.pick(*) },
    );
    return gather %direction{$direction}();
}

say weird(<a b c>, :direction<backward> );          # OUTPUT: «(c b a)␤»
```

If values need to be mutable on the caller side, use [take-rw](/type/Mu#routine_take-rw).

Note that the [`Seq`](/type/Seq) created by `gather/take` may be coerced to another type. An example with assignment to a hash:

```raku
my %h = gather { take "foo" => 1; take "bar" => 2};
say %h;                   # OUTPUT: «{bar => 2, foo => 1}␤»
```

**Note**: `gather/take` must not be used to collect results from `react/whenever`. The `whenever` block is not run from the thread that runs the `gather/react`, but the thread that runs the `emit`. On this thread, there is no handler for the control exception thrown by `take`, causing it to error out.


## dist_zef-lizmat-Text-Emoji.md
## Chunk 1 of 3
[![Actions Status](https://github.com/lizmat/Text-Emoji/actions/workflows/linux.yml/badge.svg)](https://github.com/lizmat/Text-Emoji/actions) [![Actions Status](https://github.com/lizmat/Text-Emoji/actions/workflows/macos.yml/badge.svg)](https://github.com/lizmat/Text-Emoji/actions) [![Actions Status](https://github.com/lizmat/Text-Emoji/actions/workflows/windows.yml/badge.svg)](https://github.com/lizmat/Text-Emoji/actions)

# NAME

Text::Emoji - provide :text: to emoji translation

# SYNOPSIS

```
use Text::Emoji;

say to-emoji("I :heart: :beer:");  # I ❤ 🍺

say to-text(":I: ❤ 🍺");  # I :heart: :beer:

```

# DESCRIPTION

The `Text::Emoji` distribution contains information about transforming `:text:` to emoji transliteration. As such it exports a number of subroutines.

It also installs a convenience script `em` that will convert to emojis any arguments from the command line or from standard input.

# SUBROUTINES

## to-emoji

```
say to-emoji("I :heart: :beer:");                     # I ❤ 🍺

say to-emoji("I :love: :beer:", :love<❤>);           # I ❤ 🍺
say to-emoji("I :love: :beer:", :love<heart>);        # I ❤ 🍺
say to-emoji("I :love: :beer:", %(love => "❤"));     # I ❤ 🍺
say to-emoji("I :love: :beer:", %(love => "heart"));  # I ❤ 🍺

say to-emoji("baby: :baby-bottle::babybottle:");  # baby: 🍼🍼

```

The `to-emoji` subroutine in its simplest form takes a string as the first argument and attempt to transform any known emoji strings of the form `:word:` into the associated emoji. Note that the word *may* contain hyphens, but they are optional.

Additional mapping info may be specified as additional named arguments, or as a hash. The value for each additional mapping may be either the emoji directly, or the text equivalent of the emoji. Note that all text in these additional mappings, should be in **lowercase** only.

## to-text

```
say to-text("I ❤ 🍺");                      # I :heart: :beer:
say to-text("I ❤ 🍺", :love<❤>);           # I :love: :beer:
say to-text("I ❤ 🍺", :love<heart>);        # I :love: :beer:
say to-text("I ❤ 🍺", %(love => "❤"));     # I :love: :beer:
say to-text("I ❤ 🍺", %(love => "heart"));  # I :love: :beer:

```

The `to-text` subroutine in its simplest form takes a string as the first argument and attempt to transform any known emojis to the shortest possible `:word:` form known for that emoji.

The same type of additional map information as can be specified with `to-emoji`, can be specified with `to-text`.

## raw-emoji-data

```
say raw-emoji-data<❤>.keys;
# (aliases category description emoji ios_version tags unicode_version)

```

The `raw-emoji-data` subroutine returns a `Map`, keyed to the supported emojis. The value associated with is a `Map` as well, which can be best described by its JSON representation:

```
{
  "description": "red heart",
  "category": "Smileys & Emotion",
  "aliases": [
    "heart"
  ],
  "tags": [
    "love"
  ],
  "unicode_version": "",
  "ios_version": "6.0"
}

```

# SCRIPTS

## em

```
$ em I :heart: :beer:
I ❤ 🍺

$ echo I :heart: :beer: | em
I ❤ 🍺

```

The `em` script converts any text given either on the command line, or from STDIN, to emojis where appropriate.

# MAPPINGS PROVIDED

## Activities

| name | emoji | name | emoji | name | emoji |
| --- | --- | --- | --- | --- | --- |
| 1st-place-medal | 🥇 | 2nd-place-medal | 🥈 | 3rd-place-medal | 🥉 |
| 8ball | 🎱 | art | 🎨 | badminton | 🏸 |
| balloon | 🎈 | bamboo | 🎍 | baseball | ⚾ |
| basketball | 🏀 | black-joker | 🃏 | bowling | 🎳 |
| boxing-glove | 🥊 | chess-pawn | ♟ | christmas-tree | 🎄 |
| clubs | ♣ | confetti-ball | 🎊 | cricket-game | 🏏 |
| crystal-ball | 🔮 | curling-stone | 🥌 | dart | 🎯 |
| diamonds | ♦ | diving-mask | 🤿 | dolls | 🎎 |
| field-hockey | 🏑 | firecracker | 🧨 | fireworks | 🎆 |
| fishing-pole-and-fish | 🎣 | flags | 🎏 | flower-playing-cards | 🎴 |
| flying-disc | 🥏 | football | 🏈 | framed-picture | 🖼 |
| game-die | 🎲 | gift | 🎁 | goal-net | 🥅 |
| golf | ⛳ | gun | 🔫 | hearts | ♥ |
| ice-hockey | 🏒 | ice-skate | ⛸ | jack-o-lantern | 🎃 |
| jigsaw | 🧩 | joystick | 🕹 | kite | 🪁 |
| knot | 🪢 | lacrosse | 🥍 | magic-wand | 🪄 |
| mahjong | 🀄 | martial-arts-uniform | 🥋 | medal-military | 🎖 |
| medal-sports | 🏅 | mirror-ball | 🪩 | nesting-dolls | 🪆 |
| performing-arts | 🎭 | pinata | 🪅 | ping-pong | 🏓 |
| red-envelope | 🧧 | reminder-ribbon | 🎗 | ribbon | 🎀 |
| rice-scene | 🎑 | rugby-football | 🏉 | running-shirt-with-sash | 🎽 |
| sewing-needle | 🪡 | ski | 🎿 | sled | 🛷 |
| slot-machine | 🎰 | soccer | ⚽ | softball | 🥎 |
| spades | ♠ | sparkler | 🎇 | sparkles | ✨ |
| tada | 🎉 | tanabata-tree | 🎋 | teddy-bear | 🧸 |
| tennis | 🎾 | thread | 🧵 | ticket | 🎫 |
| tickets | 🎟 | trophy | 🏆 | video-game | 🎮 |
| volleyball | 🏐 | wind-chime | 🎐 | yarn | 🧶 |
| yo-yo | 🪀 |  |  |  |  |

## Animals & Nature

| name | emoji | name | emoji | name | emoji |
| --- | --- | --- | --- | --- | --- |
| ant | 🐜 | baby-chick | 🐤 | badger | 🦡 |
| bat | 🦇 | bear | 🐻 | beaver | 🦫 |
| bee | 🐝 | beetle | 🪲 | bird | 🐦 |
| bison | 🦬 | black-bird | 🐦⬛ | black-cat | 🐈⬛ |
| blossom | 🌼 | blowfish | 🐡 | boar | 🐗 |
| bouquet | 💐 | bug | 🐛 | butterfly | 🦋 |
| cactus | 🌵 | camel | 🐫 | cat | 🐱 |
| cat2 | 🐈 | cherry-blossom | 🌸 | chicken | 🐔 |
| chipmunk | 🐿 | cockroach | 🪳 | coral | 🪸 |
| cow | 🐮 | cow2 | 🐄 | cricket | 🦗 |
| crocodile | 🐊 | deciduous-tree | 🌳 | deer | 🦌 |
| dodo | 🦤 | dog | 🐶 | dog2 | 🐕 |
| dolphin | 🐬 | donkey | 🫏 | dove | 🕊 |
| dragon | 🐉 | dragon-face | 🐲 | dromedary-camel | 🐪 |
| duck | 🦆 | eagle | 🦅 | ear-of-rice | 🌾 |
| elephant | 🐘 | empty-nest | 🪹 | evergreen-tree | 🌲 |
| fallen-leaf | 🍂 | feather | 🪶 | feet | 🐾 |
| fish | 🐟 | flamingo | 🦩 | fly | 🪰 |
| four-leaf-clover | 🍀 | fox-face | 🦊 | frog | 🐸 |
| giraffe | 🦒 | goat | 🐐 | goose | 🪿 |
| gorilla | 🦍 | guide-dog | 🦮 | hamster | 🐹 |
| hatched-chick | 🐥 | hatching-chick | 🐣 | hedgehog | 🦔 |
| herb | 🌿 | hibiscus | 🌺 | hippopotamus | 🦛 |
| horse | 🐴 | hyacinth | 🪻 | jellyfish | 🪼 |
| kangaroo | 🦘 | koala | 🐨 | lady-beetle | 🐞 |
| leaves | 🍃 | leopard | 🐆 | lion | 🦁 |
| lizard | 🦎 | llama | 🦙 | lotus | 🪷 |
| mammoth | 🦣 | maple-leaf | 🍁 | microbe | 🦠 |
| monkey | 🐒 | monkey-face | 🐵 | moose | 🫎 |
| mosquito | 🦟 | mouse | 🐭 | mouse2 | 🐁 |
| mushroom | 🍄 | nest-with-eggs | 🪺 | octopus | 🐙 |
| orangutan | 🦧 | otter | 🦦 | owl | 🦉 |
| ox | 🐂 | palm-tree | 🌴 | panda-face | 🐼 |
| parrot | 🦜 | peacock | 🦚 | penguin | 🐧 |
| pig | 🐷 | pig-nose | 🐽 | pig2 | 🐖 |
| polar-bear | 🐻❄ | poodle | 🐩 | potted-plant | 🪴 |
| rabbit | 🐰 | rabbit2 | 🐇 | raccoon | 🦝 |
| racehorse | 🐎 | ram | 🐏 | rat | 🐀 |
| rhinoceros | 🦏 | rooster | 🐓 | rose | 🌹 |
| rosette | 🏵 | sauropod | 🦕 | scorpion | 🦂 |
| seal | 🦭 | seedling | 🌱 | service-dog | 🐕🦺 |
| shamrock | ☘ | shark | 🦈 | sheep | 🐑 |
| shell | 🐚 | skunk | 🦨 | sloth | 🦥 |
| snail | 🐌 | snake | 🐍 | spider | 🕷 |
| spider-web | 🕸 | sunflower | 🌻 | swan | 🦢 |
| t-rex | 🦖 | tiger | 🐯 | tiger2 | 🐅 |
| tropical-fish | 🐠 | tulip | 🌷 | turkey | 🦃 |
| turtle | 🐢 | unicorn | 🦄 | water-buffalo | 🐃 |
| whale | 🐳 | whale2 | 🐋 | white-flower | 💮 |
| wilted-flower | 🥀 | wing | 🪽 | wolf | 🐺 |
| worm | 🪱 | zebra | 🦓 |  |  |

## Flags

| name | emoji | name | emoji | name | emoji |
| --- | --- | --- | --- | --- | --- |
| afghanistan | 🇦🇫 | aland-islands | 🇦🇽 | albania | 🇦🇱 |
| algeria | 🇩🇿 | american-samoa | 🇦🇸 | andorra | 🇦🇩 |
| angola | 🇦🇴 | anguilla | 🇦🇮 | antarctica | 🇦🇶 |
| antigua-barbuda | 🇦🇬 | argentina | 🇦🇷 | armenia | 🇦🇲 |
| aruba | 🇦🇼 | ascension-island | 🇦🇨 | australia | 🇦🇺 |
| austria | 🇦🇹 | azerbaijan | 🇦🇿 | bahamas | 🇧🇸 |
| bahrain | 🇧🇭 | bangladesh | 🇧🇩 | barbados | 🇧🇧 |
| belarus | 🇧🇾 | belgium | 🇧🇪 | belize | 🇧🇿 |
| benin | 🇧🇯 | bermuda | 🇧🇲 | bhutan | 🇧🇹 |
| black-flag | 🏴 | bolivia | 🇧🇴 | bosnia-herzegovina | 🇧🇦 |
| botswana | 🇧🇼 | bouvet-island | 🇧🇻 | brazil | 🇧🇷 |
| british-indian-ocean-territory | 🇮🇴 | british-virgin-islands | 🇻🇬 | brunei | 🇧🇳 |
| bulgaria | 🇧🇬 | burkina-faso | 🇧🇫 | burundi | 🇧🇮 |
| cambodia | 🇰🇭 | cameroon | 🇨🇲 | canada | 🇨🇦 |
| canary-islands | 🇮🇨 | cape-verde | 🇨🇻 | caribbean-netherlands | 🇧🇶 |
| cayman-islands | 🇰🇾 | central-african-republic | 🇨🇫 | ceuta-melilla | 🇪🇦 |
| chad | 🇹🇩 | checkered-flag | 🏁 | chile | 🇨🇱 |
| christmas-island | 🇨🇽 | clipperton-island | 🇨🇵 | cn | 🇨🇳 |
| cocos-islands | 🇨🇨 | colombia | 🇨🇴 | comoros | 🇰🇲 |
| congo-brazzaville | 🇨🇬 | congo-kinshasa | 🇨🇩 | cook-islands | 🇨🇰 |
| costa-rica | 🇨🇷 | cote-divoire | 🇨🇮 | croatia | 🇭🇷 |
| crossed-flags | 🎌 | cuba | 🇨🇺 | curacao | 🇨🇼 |
| cyprus | 🇨🇾 | czech-republic | 🇨🇿 | de | 🇩🇪 |
| denmark | 🇩🇰 | diego-garcia | 🇩🇬 | djibouti | 🇩🇯 |
| dominica | 🇩🇲 | dominican-republic | 🇩🇴 | ecuador | 🇪🇨 |
| egypt | 🇪🇬 | el-salvador | 🇸🇻 | england | 🏴 |
| equatorial-guinea | 🇬🇶 | eritrea | 🇪🇷 | es | 🇪🇸 |
| estonia | 🇪🇪 | ethiopia | 🇪🇹 | eu | 🇪🇺 |
| falkland-islands | 🇫🇰 | faroe-islands | 🇫🇴 | fiji | 🇫🇯 |
| finland | 🇫🇮 | fr | 🇫🇷 | french-guiana | 🇬🇫 |
| french-polynesia | 🇵🇫 | french-southern-territories | 🇹🇫 | gabon | 🇬🇦 |
| gambia | 🇬🇲 | gb | 🇬🇧 | georgia | 🇬🇪 |
| ghana | 🇬🇭 | gibraltar | 🇬🇮 | greece | 🇬🇷 |
| greenland | 🇬🇱 | grenada | 🇬🇩 | guadeloupe | 🇬🇵 |
| guam | 🇬🇺 | guatemala | 🇬🇹 | guernsey | 🇬🇬 |
| guinea | 🇬🇳 | guinea-bissau | 🇬🇼 | guyana | 🇬🇾 |
| haiti | 🇭🇹 | heard-mcdonald-islands | 🇭🇲 | honduras | 🇭🇳 |
| hong-kong | 🇭🇰 | hungary | 🇭🇺 | iceland | 🇮🇸 |
| india | 🇮🇳 | indonesia | 🇮🇩 | iran | 🇮🇷 |
| iraq | 🇮🇶 | ireland | 🇮🇪 | isle-of-man | 🇮🇲 |
| israel | 🇮🇱 | it | 🇮🇹 | jamaica | 🇯🇲 |
| jersey | 🇯🇪 | jordan | 🇯🇴 | jp | 🇯🇵 |
| kazakhstan | 🇰🇿 | kenya | 🇰🇪 | kiribati | 🇰🇮 |
| kosovo | 🇽🇰 | kr | 🇰🇷 | kuwait | 🇰🇼 |
| kyrgyzstan | 🇰🇬 | laos | 🇱🇦 | latvia | 🇱🇻 |
| lebanon | 🇱🇧 | lesotho | 🇱🇸 | liberia | 🇱🇷 |
| libya | 🇱🇾 | liechtenstein | 🇱🇮 | lithuania | 🇱🇹 |
| luxembourg | 🇱🇺 | macau | 🇲🇴 | macedonia | 🇲🇰 |
| madagascar | 🇲🇬 | malawi | 🇲🇼 | malaysia | 🇲🇾 |
| maldives | 🇲🇻 | mali | 🇲🇱 | malta | 🇲🇹 |
| marshall-islands | 🇲🇭 | martinique | 🇲🇶 | mauritania | 🇲🇷 |
| mauritius | 🇲🇺 | mayotte | 🇾🇹 | mexico | 🇲🇽 |
| micronesia | 🇫🇲 | moldova | 🇲🇩 | monaco | 🇲🇨 |
| mongolia | 🇲🇳 | montenegro | 🇲🇪 | montserrat | 🇲🇸 |
| morocco | 🇲🇦 | mozambique | 🇲🇿 | myanmar | 🇲🇲 |
| namibia | 🇳🇦 | nauru | 🇳🇷 | nepal | 🇳🇵 |
| netherlands | 🇳🇱 | new-caledonia | 🇳🇨 | new-zealand | 🇳🇿 |
| nicaragua | 🇳🇮 | niger | 🇳🇪 | nigeria | 🇳🇬 |
| niue | 🇳🇺 | norfolk-island | 🇳🇫 | north-korea | 🇰🇵 |
| northern-mariana-islands | 🇲🇵 | norway | 🇳🇴 | oman | 🇴🇲 |
| pakistan | 🇵🇰 | palau | 🇵🇼 | palestinian-territories | 🇵🇸 |
| panama | 🇵🇦 | papua-new-guinea | 🇵🇬 | paraguay | 🇵🇾 |
| peru | 🇵🇪 | philippines | 🇵🇭 | pirate-flag | 🏴☠ |
| pitcairn-islands | 🇵🇳 | poland | 🇵🇱 | portugal | 🇵🇹 |
| puerto-rico | 🇵🇷 | qatar | 🇶🇦 | rainbow-flag | 🏳🌈 |
| reunion | 🇷🇪 | romania | 🇷🇴 | ru | 🇷🇺 |
| rwanda | 🇷🇼 | samoa | 🇼🇸 | san-marino | 🇸🇲 |
| sao-tome-principe | 🇸🇹 | saudi-arabia | 🇸🇦 | scotland | 🏴 |
| senegal | 🇸🇳 | serbia | 🇷🇸 | seychelles | 🇸🇨 |
| sierra-leone | 🇸🇱 | singapore | 🇸🇬 | sint-maarten | 🇸🇽 |
| slovakia | 🇸🇰 | slovenia | 🇸🇮 | solomon-islands | 🇸🇧 |
| somalia | 🇸🇴 | south-africa | 🇿🇦 | south-georgia-south-sandwich-islands | 🇬🇸 |
| south-sudan | 🇸🇸 | sri-lanka | 🇱🇰 | st-barthelemy | 🇧🇱 |
| st-helena | 🇸🇭 | st-kitts-nevis | 🇰🇳 | st-lucia | 🇱🇨 |
| st-martin | 🇲🇫 | st-pierre-miquelon | 🇵🇲 | st-vincent-grenadines | 🇻🇨 |
| sudan | 🇸🇩 | suriname | 🇸🇷 | svalbard-jan-mayen | 🇸🇯 |
| swaziland | 🇸🇿 | sweden | 🇸🇪 | switzerland | 🇨🇭 |
| syria | 🇸🇾 | taiwan | 🇹🇼 | tajikistan | 🇹🇯 |
| tanzania | 🇹🇿 | thailand | 🇹🇭 | timor-leste | 🇹🇱 |
| togo | 🇹🇬 | tokelau | 🇹🇰 | tonga | 🇹🇴 |
| tr | 🇹🇷 | transgender-flag | 🏳⚧ | triangular-flag-on-post | 🚩 |
| trinidad-tobago | 🇹🇹 | tristan-da-cunha | 🇹🇦 | tunisia | 🇹🇳 |
| turkmenistan | 🇹🇲 | turks-caicos-islands | 🇹🇨 | tuvalu | 🇹🇻 |
| uganda | 🇺🇬 | ukraine | 🇺🇦 | united-arab-emirates | 🇦🇪 |
| united-nations | 🇺🇳 | uruguay | 🇺🇾 | us | 🇺🇸 |
| us-outlying-islands | 🇺🇲 | us-virgin-islands | 🇻🇮 | uzbekistan | 🇺🇿 |
| vanuatu | 🇻🇺 | vatican-city | 🇻🇦 | venezuela | 🇻🇪 |
| vietnam | 🇻🇳 | wales | 🏴 | wallis-futuna | 🇼🇫 |
| western-sahara | 🇪🇭 | white-flag | 🏳 | yemen | 🇾🇪 |
| zambia | 🇿🇲 | zimbabwe | 🇿🇼 |  |  |

## Food & Drink

| name | emoji | name | emoji | name | emoji |
| --- | --- | --- | --- | --- | --- |
| amphora | 🏺 | apple | 🍎 | avocado | 🥑 |
| baby-bottle | 🍼 | bacon | 🥓 | bagel | 🥯 |
| baguette-bread | 🥖 | banana | 🍌 | beans | 🫘 |
| beer | 🍺 | beers | 🍻 | bell-pepper | 🫑 |
| bento | 🍱 | beverage-box | 🧃 | birthday | 🎂 |
| blueberries | 🫐 | bowl-with-spoon | 🥣 | bread | 🍞 |
| broccoli | 🥦 | bubble-tea | 🧋 | burrito | 🌯 |
| butter | 🧈 | cake | 🍰 | candy | 🍬 |
| canned-food | 🥫 | carrot | 🥕 | champagne | 🍾 |
| cheese | 🧀 | cherries | 🍒 | chestnut | 🌰 |
| chocolate-bar | 🍫 | chopsticks | 🥢 | clinking-glasses | 🥂 |
| cocktail | 🍸 | coconut | 🥥 | coffee | ☕ |
| cookie | 🍪 | corn | 🌽 | crab | 🦀 |
| croissant | 🥐 | cucumber | 🥒 | cup-with-straw | 🥤 |
| cupcake | 🧁 | curry | 🍛 | custard | 🍮 |
| cut-of-meat | 🥩 | dango | 🍡 | doughnut | 🍩 |
| dumpling | 🥟 | egg | 🥚 | eggplant | 🍆 |
| falafel | 🧆 | fish-cake | 🍥 | flatbread | 🫓 |
| fondue | 🫕 | fork-and-knife | 🍴 | fortune-cookie | 🥠 |
| fried-egg | 🍳 | fried-shrimp | 🍤 | fries | 🍟 |
| garlic | 🧄 | ginger-root | 🫚 | grapes | 🍇 |
| green-apple | 🍏 | green-salad | 🥗 | hamburger | 🍔 |
| hocho | 🔪 | honey-pot | 🍯 | hot-pepper | 🌶 |
| hotdog | 🌭 | ice-cream | 🍨 | ice-cube | 🧊 |
| icecream | 🍦 | jar | 🫙 | kiwi-fruit | 🥝 |
| leafy-green | 🥬 | lemon | 🍋 | lobster | 🦞 |
| lollipop | 🍭 | mango | 🥭 | mate | 🧉 |
| meat-on-bone | 🍖 | melon | 🍈 | milk-glass | 🥛 |
| moon-cake | 🥮 | oden | 🍢 | olive | 🫒 |
| onion | 🧅 | oyster | 🦪 | pancakes | 🥞 |
| pea-pod | 🫛 | peach | 🍑 | peanuts | 🥜 |
| pear | 🍐 | pie | 🥧 | pineapple | 🍍 |
| pizza | 🍕 | plate-with-cutlery | 🍽 | popcorn | 🍿 |
| potato | 🥔 | poultry-leg | 🍗 | pouring-liquid | 🫗 |
| pretzel | 🥨 | ramen | 🍜 | rice | 🍚 |
| rice-ball | 🍙 | rice-cracker | 🍘 | sake | 🍶 |
| salt | 🧂 | sandwich | 🥪 | shallow-pan-of-food | 🥘 |
| shaved-ice | 🍧 | shrimp | 🦐 | spaghetti | 🍝 |
| spoon | 🥄 | squid | 🦑 | stew | 🍲 |
| strawberry | 🍓 | stuffed-flatbread | 🥙 | sushi | 🍣 |
| sweet-potato | 🍠 | taco | 🌮 | takeout-box | 🥡 |
| tamale | 🫔 | tangerine | 🍊 | tea | 🍵 |
| teapot | 🫖 | tomato | 🍅 | tropical-drink | 🍹 |
| tumbler-glass | 🥃 | waffle | 🧇 | watermelon | 🍉 |
| wine-glass | 🍷 |  |  |  |  |

## Objects

| name | emoji | name | emoji | name | emoji |
| --- | --- | --- | --- | --- | --- |
| abacus | 🧮 | accordion | 🪗 | adhesive-bandage | 🩹 |
| alembic | ⚗ | athletic-shoe | 👟 | axe | 🪓 |
| balance-scale | ⚖ | ballet-shoes | 🩰 | ballot-box | 🗳 |
| banjo | 🪕 | bar-chart | 📊 | basket | 🧺 |
| bathtub | 🛁 | battery | 🔋 | bed | 🛏 |
| bell | 🔔 | bikini | 👙 | billed-cap | 🧢 |
| black-nib | ✒ | blue-book | 📘 | bomb | 💣 |
| book | 📖 | bookmark | 🔖 | bookmark-tabs | 📑 |
| books | 📚 | boomerang | 🪃 | boot | 👢 |
| bow-and-arrow | 🏹 | briefcase | 💼 | broom | 🧹 |
| bubbles | 🫧 | bucket | 🪣 | bulb | 💡 |
| calendar | 📆 | calling | 📲 | camera | 📷 |
| camera-flash | 📸 | candle | 🕯 | card-file-box | 🗃 |
| card-index | 📇 | card-index-dividers | 🗂 | carpentry-saw | 🪚 |
| cd | 💿 | chains | ⛓ | chair | 🪑 |
| chart | 💹 | chart-with-downwards-trend | 📉 | chart-with-upwards-trend | 📈 |
| clamp | 🗜 | clapper | 🎬 | clipboard | 📋 |
| closed-book | 📕 | closed-lock-with-key | 🔐 | coat | 🧥 |
| coffin | ⚰ | coin | 🪙 | computer | 💻 |
| computer-mouse | 🖱 | control-knobs | 🎛 | couch-and-lamp | 🛋 |
| crayon | 🖍 | credit-card | 💳 | crossed-swords | ⚔ |
| crown | 👑 | crutch | 🩼 | dagger | 🗡 |
| dark-sunglasses | 🕶 | date | 📅 | desktop-computer | 🖥 |
| diya-lamp | 🪔 | dna | 🧬 | dollar | 💵 |
| door | 🚪 | dress | 👗 | drop-of-blood | 🩸 |
| drum | 🥁 | dvd | 📀 | electric-plug | 🔌 |
| elevator | 🛗 | email | 📧 | envelope | ✉ |
| envelope-with-arrow | 📩 | euro | 💶 | eyeglasses | 👓 |
| fax | 📠 | file-cabinet | 🗄 | file-folder | 📁 |
| film-projector | 📽 | film-strip | 🎞 | fire-extinguisher | 🧯 |
| flashlight | 🔦 | flat-shoe | 🥿 | floppy-disk | 💾 |
| flute | 🪈 | folding-hand-fan | 🪭 | fountain-pen | 🖋 |
| funeral-urn | ⚱ | gear | ⚙ | gem | 💎 |
| gloves | 🧤 | goggles | 🥽 | green-book | 📗 |
| guitar | 🎸 | hair-pick | 🪮 | hammer | 🔨 |
| hammer-and-pick | ⚒ | hammer-and-wrench | 🛠 | hamsa | 🪬 |
| handbag | 👜 | headphones | 🎧 | headstone | 🪦 |
| high-heel | 👠 | hiking-boot | 🥾 | hook | 🪝 |
| identification-card | 🪪 | inbox-tray | 📥 | incoming-envelope | 📨 |
| iphone | 📱 | izakaya-lantern | 🏮 | jeans | 👖 |
| key | 🔑 | keyboard | ⌨ | kimono | 👘 |
| lab-coat | 🥼 | label | 🏷 | ladder | 🪜 |
| ledger | 📒 | level-slider | 🎚 | link | 🔗 |
| lipstick | 💄 | lock | 🔒 | lock-with-ink-pen | 🔏 |
| long-drum | 🪘 | lotion-bottle | 🧴 | loud-sound | 🔊 |
| loudspeaker | 📢 | low-battery | 🪫 | mag | 🔍 |
| mag-right | 🔎 | magnet | 🧲 | mailbox | 📫 |
| mailbox-closed | 📪 | mailbox-with-mail | 📬 | mailbox-with-no-mail | 📭 |
| mans-shoe | 👞 | maracas | 🪇 | mega | 📣 |
| memo | 📝 | microphone | 🎤 | microscope | 🔬 |
| military-helmet | 🪖 | minidisc | 💽 | mirror | 🪞 |
| money-with-wings | 💸 | moneybag | 💰 | mortar-board | 🎓 |
| mouse-trap | 🪤 | movie-camera | 🎥 | moyai | 🗿 |
| musical-keyboard | 🎹 | musical-note | 🎵 | musical-score | 🎼 |
| mute | 🔇 | nazar-amulet | 🧿 | necktie | 👔 |
| newspaper | 📰 | newspaper-roll | 🗞 | no-bell | 🔕 |
| notebook | 📓 | notebook-with-decorative-cover | 📔 | notes | 🎶 |
| nut-and-bolt | 🔩 | old-key | 🗝 | one-piece-swimsuit | 🩱 |
| open-file-folder | 📂 | orange-book | 📙 | outbox-tray | 📤 |
| package | 📦 | page-facing-up | 📄 | page-with-curl | 📃 |
| pager | 📟 | paintbrush | 🖌 | paperclip | 📎 |
| paperclips | 🖇 | pen | 🖊 | pencil2 | ✏ |
| petri-dish | 🧫 | phone | ☎ | pick | ⛏ |
| pill | 💊 | placard | 🪧 | plunger | 🪠 |
| postal-horn | 📯 | postbox | 📮 | pouch | 👝 |
| pound | 💷 | prayer-beads | 📿 | printer | 🖨 |
| probing-cane | 🦯 | purse | 👛 | pushpin | 📌 |
| radio | 📻 | razor | 🪒 | receipt | 🧾 |
| rescue-worker-helmet | ⛑ | ring | 💍 | roll-of-paper | 🧻 |
| round-pushpin | 📍 | safety-pin | 🧷 | safety-vest | 🦺 |
| sandal | 👡 | sari | 🥻 | satellite | 📡 |
| saxophone | 🎷 | scarf | 🧣 | school-satchel | 🎒 |
| scissors | ✂ | screwdriver | 🪛 | scroll | 📜 |
| shield | 🛡 | shirt | 👕 | shopping | 🛍 |
| shopping-cart | 🛒 | shorts | 🩳 | shower | 🚿 |
| smoking | 🚬 | soap | 🧼 | socks | 🧦 |
| sound | 🔉 | speaker | 🔈 | spiral-calendar | 🗓 |
| spiral-notepad | 🗒 | sponge | 🧽 | stethoscope | 🩺 |
| straight-ruler | 📏 | studio-microphone | 🎙 | swim-brief | 🩲 |
| syringe | 💉 | telephone-receiver | 📞 | telescope | 🔭 |
| test-tube | 🧪 | thong-sandal | 🩴 | toilet | 🚽 |
| toolbox | 🧰 | toothbrush | �


## dist_zef-lizmat-Text-Emoji.md
## Chunk 2 of 3
�� | tophat | 🎩 |
| trackball | 🖲 | triangular-ruler | 📐 | trumpet | 🎺 |
| tv | 📺 | unlock | 🔓 | vhs | 📼 |
| video-camera | 📹 | violin | 🎻 | wastebasket | 🗑 |
| window | 🪟 | womans-clothes | 👚 | womans-hat | 👒 |
| wrench | 🔧 | x-ray | 🩻 | yen | 💴 |

## People & Body

| name | emoji | name | emoji | name | emoji |
| --- | --- | --- | --- | --- | --- |
| +1 | 👍 | -1 | 👎 | adult | 🧑 |
| anatomical-heart | 🫀 | angel | 👼 | artist | 🧑🎨 |
| astronaut | 🧑🚀 | baby | 👶 | bald-man | 👨🦲 |
| bald-woman | 👩🦲 | bath | 🛀 | bearded-person | 🧔 |
| bicyclist | 🚴 | biking-man | 🚴♂ | biking-woman | 🚴♀ |
| biting-lip | 🫦 | blond-haired-man | 👱♂ | blond-haired-person | 👱 |
| blond-haired-woman | 👱♀ | bone | 🦴 | bouncing-ball-man | ⛹♂ |
| bouncing-ball-person | ⛹ | bouncing-ball-woman | ⛹♀ | bow | 🙇 |
| bowing-man | 🙇♂ | bowing-woman | 🙇♀ | boy | 👦 |
| brain | 🧠 | breast-feeding | 🤱 | business-suit-levitating | 🕴 |
| bust-in-silhouette | 👤 | busts-in-silhouette | 👥 | call-me-hand | 🤙 |
| cartwheeling | 🤸 | child | 🧒 | clap | 👏 |
| climbing | 🧗 | climbing-man | 🧗♂ | climbing-woman | 🧗♀ |
| construction-worker | 👷 | construction-worker-man | 👷♂ | construction-worker-woman | 👷♀ |
| cook | 🧑🍳 | couple | 👫 | couple-with-heart | 💑 |
| couple-with-heart-man-man | 👨❤👨 | couple-with-heart-woman-man | 👩❤👨 | couple-with-heart-woman-woman | 👩❤👩 |
| couplekiss | 💏 | couplekiss-man-man | 👨❤💋👨 | couplekiss-man-woman | 👩❤💋👨 |
| couplekiss-woman-woman | 👩❤💋👩 | crossed-fingers | 🤞 | curly-haired-man | 👨🦱 |
| curly-haired-woman | 👩🦱 | dancers | 👯 | dancing-men | 👯♂ |
| dancing-women | 👯♀ | deaf-man | 🧏♂ | deaf-person | 🧏 |
| deaf-woman | 🧏♀ | detective | 🕵 | ear | 👂 |
| ear-with-hearing-aid | 🦻 | elf | 🧝 | elf-man | 🧝♂ |
| elf-woman | 🧝♀ | eye | 👁 | eyes | 👀 |
| facepalm | 🤦 | factory-worker | 🧑🏭 | fairy | 🧚 |
| fairy-man | 🧚♂ | fairy-woman | 🧚♀ | family | 👪 |
| family-man-boy | 👨👦 | family-man-boy-boy | 👨👦👦 | family-man-girl | 👨👧 |
| family-man-girl-boy | 👨👧👦 | family-man-girl-girl | 👨👧👧 | family-man-man-boy | 👨👨👦 |
| family-man-man-boy-boy | 👨👨👦👦 | family-man-man-girl | 👨👨👧 | family-man-man-girl-boy | 👨👨👧👦 |
| family-man-man-girl-girl | 👨👨👧👧 | family-man-woman-boy | 👨👩👦 | family-man-woman-boy-boy | 👨👩👦👦 |
| family-man-woman-girl | 👨👩👧 | family-man-woman-girl-boy | 👨👩👧👦 | family-man-woman-girl-girl | 👨👩👧👧 |
| family-woman-boy | 👩👦 | family-woman-boy-boy | 👩👦👦 | family-woman-girl | 👩👧 |
| family-woman-girl-boy | 👩👧👦 | family-woman-girl-girl | 👩👧👧 | family-woman-woman-boy | 👩👩👦 |
| family-woman-woman-boy-boy | 👩👩👦👦 | family-woman-woman-girl | 👩👩👧 | family-woman-woman-girl-boy | 👩👩👧👦 |
| family-woman-woman-girl-girl | 👩👩👧👧 | farmer | 🧑🌾 | female-detective | 🕵♀ |
| firefighter | 🧑🚒 | fist-left | 🤛 | fist-oncoming | 👊 |
| fist-raised | ✊ | fist-right | 🤜 | foot | 🦶 |
| footprints | 👣 | frowning-man | 🙍♂ | frowning-person | 🙍 |
| frowning-woman | 🙍♀ | genie | 🧞 | genie-man | 🧞♂ |
| genie-woman | 🧞♀ | girl | 👧 | golfing | 🏌 |
| golfing-man | 🏌♂ | golfing-woman | 🏌♀ | guard | 💂 |
| guardsman | 💂♂ | guardswoman | 💂♀ | haircut | 💇 |
| haircut-man | 💇♂ | haircut-woman | 💇♀ | hand | ✋ |
| hand-with-index-finger-and-thumb-crossed | 🫰 | handball-person | 🤾 | handshake | 🤝 |
| health-worker | 🧑⚕ | heart-hands | 🫶 | horse-racing | 🏇 |
| index-pointing-at-the-viewer | 🫵 | judge | 🧑⚖ | juggling-person | 🤹 |
| kneeling-man | 🧎♂ | kneeling-person | 🧎 | kneeling-woman | 🧎♀ |
| leftwards-hand | 🫲 | leftwards-pushing-hand | 🫷 | leg | 🦵 |
| lips | 👄 | lotus-position | 🧘 | lotus-position-man | 🧘♂ |
| lotus-position-woman | 🧘♀ | love-you-gesture | 🤟 | lungs | 🫁 |
| mage | 🧙 | mage-man | 🧙♂ | mage-woman | 🧙♀ |
| male-detective | 🕵♂ | man | 👨 | man-artist | 👨🎨 |
| man-astronaut | 👨🚀 | man-beard | 🧔♂ | man-cartwheeling | 🤸♂ |
| man-cook | 👨🍳 | man-dancing | 🕺 | man-facepalming | 🤦♂ |
| man-factory-worker | 👨🏭 | man-farmer | 👨🌾 | man-feeding-baby | 👨🍼 |
| man-firefighter | 👨🚒 | man-health-worker | 👨⚕ | man-in-manual-wheelchair | 👨🦽 |
| man-in-motorized-wheelchair | 👨🦼 | man-in-tuxedo | 🤵♂ | man-judge | 👨⚖ |
| man-juggling | 🤹♂ | man-mechanic | 👨🔧 | man-office-worker | 👨💼 |
| man-pilot | 👨✈ | man-playing-handball | 🤾♂ | man-playing-water-polo | 🤽♂ |
| man-scientist | 👨🔬 | man-shrugging | 🤷♂ | man-singer | 👨🎤 |
| man-student | 👨🎓 | man-teacher | 👨🏫 | man-technologist | 👨💻 |
| man-with-gua-pi-mao | 👲 | man-with-probing-cane | 👨🦯 | man-with-turban | 👳♂ |
| man-with-veil | 👰♂ | massage | 💆 | massage-man | 💆♂ |
| massage-woman | 💆♀ | mechanic | 🧑🔧 | mechanical-arm | 🦾 |
| mechanical-leg | 🦿 | men-wrestling | 🤼♂ | mermaid | 🧜♀ |
| merman | 🧜♂ | merperson | 🧜 | metal | 🤘 |
| middle-finger | 🖕 | mountain-bicyclist | 🚵 | mountain-biking-man | 🚵♂ |
| mountain-biking-woman | 🚵♀ | mrs-claus | 🤶 | muscle | 💪 |
| mx-claus | 🧑🎄 | nail-care | 💅 | ninja | 🥷 |
| no-good | 🙅 | no-good-man | 🙅♂ | no-good-woman | 🙅♀ |
| nose | 👃 | office-worker | 🧑💼 | ok-hand | 👌 |
| ok-man | 🙆♂ | ok-person | 🙆 | ok-woman | 🙆♀ |
| older-adult | 🧓 | older-man | 👴 | older-woman | 👵 |
| open-hands | 👐 | palm-down-hand | 🫳 | palm-up-hand | 🫴 |
| palms-up-together | 🤲 | people-holding-hands | 🧑🤝🧑 | people-hugging | 🫂 |
| person-bald | 🧑🦲 | person-curly-hair | 🧑🦱 | person-feeding-baby | 🧑🍼 |
| person-fencing | 🤺 | person-in-manual-wheelchair | 🧑🦽 | person-in-motorized-wheelchair | 🧑🦼 |
| person-in-tuxedo | 🤵 | person-red-hair | 🧑🦰 | person-white-hair | 🧑🦳 |
| person-with-crown | 🫅 | person-with-probing-cane | 🧑🦯 | person-with-turban | 👳 |
| person-with-veil | 👰 | pilot | 🧑✈ | pinched-fingers | 🤌 |
| pinching-hand | 🤏 | point-down | 👇 | point-left | 👈 |
| point-right | 👉 | point-up | ☝ | point-up-2 | 👆 |
| police-officer | 👮 | policeman | 👮♂ | policewoman | 👮♀ |
| pouting-face | 🙎 | pouting-man | 🙎♂ | pouting-woman | 🙎♀ |
| pray | 🙏 | pregnant-man | 🫃 | pregnant-person | 🫄 |
| pregnant-woman | 🤰 | prince | 🤴 | princess | 👸 |
| raised-back-of-hand | 🤚 | raised-hand-with-fingers-splayed | 🖐 | raised-hands | 🙌 |
| raising-hand | 🙋 | raising-hand-man | 🙋♂ | raising-hand-woman | 🙋♀ |
| red-haired-man | 👨🦰 | red-haired-woman | 👩🦰 | rightwards-hand | 🫱 |
| rightwards-pushing-hand | 🫸 | rowboat | 🚣 | rowing-man | 🚣♂ |
| rowing-woman | 🚣♀ | runner | 🏃 | running-man | 🏃♂ |
| running-woman | 🏃♀ | santa | 🎅 | sauna-man | 🧖♂ |
| sauna-person | 🧖 | sauna-woman | 🧖♀ | scientist | 🧑🔬 |
| selfie | 🤳 | shrug | 🤷 | singer | 🧑🎤 |
| skier | ⛷ | sleeping-bed | 🛌 | snowboarder | 🏂 |
| speaking-head | 🗣 | standing-man | 🧍♂ | standing-person | 🧍 |
| standing-woman | 🧍♀ | student | 🧑🎓 | superhero | 🦸 |
| superhero-man | 🦸♂ | superhero-woman | 🦸♀ | supervillain | 🦹 |
| supervillain-man | 🦹♂ | supervillain-woman | 🦹♀ | surfer | 🏄 |
| surfing-man | 🏄♂ | surfing-woman | 🏄♀ | swimmer | 🏊 |
| swimming-man | 🏊♂ | swimming-woman | 🏊♀ | teacher | 🧑🏫 |
| technologist | 🧑💻 | tipping-hand-man | 💁♂ | tipping-hand-person | 💁 |
| tipping-hand-woman | 💁♀ | tongue | 👅 | tooth | 🦷 |
| troll | 🧌 | two-men-holding-hands | 👬 | two-women-holding-hands | 👭 |
| v | ✌ | vampire | 🧛 | vampire-man | 🧛♂ |
| vampire-woman | 🧛♀ | vulcan-salute | 🖖 | walking | 🚶 |
| walking-man | 🚶♂ | walking-woman | 🚶♀ | water-polo | 🤽 |
| wave | 👋 | weight-lifting | 🏋 | weight-lifting-man | 🏋♂ |
| weight-lifting-woman | 🏋♀ | white-haired-man | 👨🦳 | white-haired-woman | 👩🦳 |
| woman | 👩 | woman-artist | 👩🎨 | woman-astronaut | 👩🚀 |
| woman-beard | 🧔♀ | woman-cartwheeling | 🤸♀ | woman-cook | 👩🍳 |
| woman-dancing | 💃 | woman-facepalming | 🤦♀ | woman-factory-worker | 👩🏭 |
| woman-farmer | 👩🌾 | woman-feeding-baby | 👩🍼 | woman-firefighter | 👩🚒 |
| woman-health-worker | 👩⚕ | woman-in-manual-wheelchair | 👩🦽 | woman-in-motorized-wheelchair | 👩🦼 |
| woman-in-tuxedo | 🤵♀ | woman-judge | 👩⚖ | woman-juggling | 🤹♀ |
| woman-mechanic | 👩🔧 | woman-office-worker | 👩💼 | woman-pilot | 👩✈ |
| woman-playing-handball | 🤾♀ | woman-playing-water-polo | 🤽♀ | woman-scientist | 👩🔬 |
| woman-shrugging | 🤷♀ | woman-singer | 👩🎤 | woman-student | 👩🎓 |
| woman-teacher | 👩🏫 | woman-technologist | 👩💻 | woman-with-headscarf | 🧕 |
| woman-with-probing-cane | 👩🦯 | woman-with-turban | 👳♀ | woman-with-veil | 👰♀ |
| women-wrestling | 🤼♀ | wrestling | 🤼 | writing-hand | ✍ |
| zombie | 🧟 | zombie-man | 🧟♂ | zombie-woman | 🧟♀ |

## Smileys & Emotion

| name | emoji | name | emoji | name | emoji |
| --- | --- | --- | --- | --- | --- |
| 100 | 💯 | alien | 👽 | anger | 💢 |
| angry | 😠 | anguished | 😧 | astonished | 😲 |
| black-heart | 🖤 | blue-heart | 💙 | blush | 😊 |
| boom | 💥 | broken-heart | 💔 | brown-heart | 🤎 |
| clown-face | 🤡 | cold-face | 🥶 | cold-sweat | 😰 |
| confounded | 😖 | confused | 😕 | cowboy-hat-face | 🤠 |
| cry | 😢 | crying-cat-face | 😿 | cupid | 💘 |
| cursing-face | 🤬 | dash | 💨 | disappointed | 😞 |
| disappointed-relieved | 😥 | disguised-face | 🥸 | dizzy | 💫 |
| dizzy-face | 😵 | dotted-line-face | 🫥 | drooling-face | 🤤 |
| exploding-head | 🤯 | expressionless | 😑 | eye-speech-bubble | 👁🗨 |
| face-exhaling | 😮💨 | face-holding-back-tears | 🥹 | face-in-clouds | 😶🌫 |
| face-with-diagonal-mouth | 🫤 | face-with-head-bandage | 🤕 | face-with-open-eyes-and-hand-over-mouth | 🫢 |
| face-with-peeking-eye | 🫣 | face-with-spiral-eyes | 😵💫 | face-with-thermometer | 🤒 |
| fearful | 😨 | flushed | 😳 | frowning | 😦 |
| frowning-face | ☹ | ghost | 👻 | gift-heart | 💝 |
| green-heart | 💚 | grey-heart | 🩶 | grimacing | 😬 |
| grin | 😁 | grinning | 😀 | hand-over-mouth | 🤭 |
| hankey | 💩 | hear-no-evil | 🙉 | heart | ❤ |
| heart-decoration | 💟 | heart-eyes | 😍 | heart-eyes-cat | 😻 |
| heart-on-fire | ❤🔥 | heartbeat | 💓 | heartpulse | 💗 |
| heavy-heart-exclamation | ❣ | hole | 🕳 | hot-face | 🥵 |
| hugs | 🤗 | hushed | 😯 | imp | 👿 |
| innocent | 😇 | japanese-goblin | 👺 | japanese-ogre | 👹 |
| joy | 😂 | joy-cat | 😹 | kiss | 💋 |
| kissing | 😗 | kissing-cat | 😽 | kissing-closed-eyes | 😚 |
| kissing-heart | 😘 | kissing-smiling-eyes | 😙 | laughing | 😆 |
| left-speech-bubble | 🗨 | light-blue-heart | 🩵 | love-letter | 💌 |
| lying-face | 🤥 | mask | 😷 | melting-face | 🫠 |
| mending-heart | ❤🩹 | money-mouth-face | 🤑 | monocle-face | 🧐 |
| nauseated-face | 🤢 | nerd-face | 🤓 | neutral-face | 😐 |
| no-mouth | 😶 | open-mouth | 😮 | orange-heart | 🧡 |
| partying-face | 🥳 | pensive | 😔 | persevere | 😣 |
| pink-heart | 🩷 | pleading-face | 🥺 | pouting-cat | 😾 |
| purple-heart | 💜 | rage | 😡 | raised-eyebrow | 🤨 |
| relaxed | ☺ | relieved | 😌 | revolving-hearts | 💞 |
| right-anger-bubble | 🗯 | robot | 🤖 | rofl | 🤣 |
| roll-eyes | 🙄 | saluting-face | 🫡 | scream | 😱 |
| scream-cat | 🙀 | see-no-evil | 🙈 | shaking-face | 🫨 |
| shushing-face | 🤫 | skull | 💀 | skull-and-crossbones | ☠ |
| sleeping | 😴 | sleepy | 😪 | slightly-frowning-face | 🙁 |
| slightly-smiling-face | 🙂 | smile | 😄 | smile-cat | 😸 |
| smiley | 😃 | smiley-cat | 😺 | smiling-face-with-tear | 🥲 |
| smiling-face-with-three-hearts | 🥰 | smiling-imp | 😈 | smirk | 😏 |
| smirk-cat | 😼 | sneezing-face | 🤧 | sob | 😭 |
| space-invader | 👾 | sparkling-heart | 💖 | speak-no-evil | 🙊 |
| speech-balloon | 💬 | star-struck | 🤩 | stuck-out-tongue | 😛 |
| stuck-out-tongue-closed-eyes | 😝 | stuck-out-tongue-winking-eye | 😜 | sunglasses | 😎 |
| sweat | 😓 | sweat-drops | 💦 | sweat-smile | 😅 |
| thinking | 🤔 | thought-balloon | 💭 | tired-face | 😫 |
| triumph | 😤 | two-hearts | 💕 | unamused | 😒 |
| upside-down-face | 🙃 | vomiting-face | 🤮 | weary | 😩 |
| white-heart | 🤍 | wink | 😉 | woozy-face | 🥴 |
| worried | 😟 | yawning-face | 🥱 | yellow-heart | 💛 |
| yum | 😋 | zany-face | 🤪 | zipper-mouth-face | 🤐 |
| zzz | 💤 |  |  |  |  |

## Symbols

| name | emoji | name | emoji | name | emoji |
| --- | --- | --- | --- | --- | --- |
| 1234 | 🔢 | a | 🅰 | ab | 🆎 |
| abc | 🔤 | abcd | 🔡 | accept | 🉑 |
| aquarius | ♒ | aries | ♈ | arrow-backward | ◀ |
| arrow-double-down | ⏬ | arrow-double-up | ⏫ | arrow-down | ⬇ |
| arrow-down-small | 🔽 | arrow-forward | ▶ | arrow-heading-down | ⤵ |
| arrow-heading-up | ⤴ | arrow-left | ⬅ | arrow-lower-left | ↙ |
| arrow-lower-right | ↘ | arrow-right | ➡ | arrow-right-hook | ↪ |
| arrow-up | ⬆ | arrow-up-down | ↕ | arrow-up-small | 🔼 |
| arrow-upper-left | ↖ | arrow-upper-right | ↗ | arrows-clockwise | 🔃 |
| arrows-counterclockwise | 🔄 | asterisk | \*⃣ | atm | 🏧 |
| atom-symbol | ⚛ | b | 🅱 | baby-symbol | 🚼 |
| back | 🔙 | baggage-claim | 🛄 | ballot-box-with-check | ☑ |
| bangbang | ‼ | beginner | 🔰 | biohazard | ☣ |
| black-circle | ⚫ | black-large-square | ⬛ | black-medium-small-square | ◾ |
| black-medium-square | ◼ | black-small-square | ▪ | black-square-button | 🔲 |
| blue-square | 🟦 | brown-circle | 🟤 | brown-square | 🟫 |
| cancer | ♋ | capital-abcd | 🔠 | capricorn | ♑ |
| children-crossing | 🚸 | cinema | 🎦 | cl | 🆑 |
| congratulations | ㊗ | cool | 🆒 | copyright | © |
| curly-loop | ➰ | currency-exchange | 💱 | customs | 🛃 |
| diamond-shape-with-a-dot-inside | 💠 | do-not-litter | 🚯 | eight | 8⃣ |
| eight-pointed-black-star | ✴ | eight-spoked-asterisk | ✳ | eject-button | ⏏ |
| end | 🔚 | exclamation | ❗ | fast-forward | ⏩ |
| female-sign | ♀ | five | 5⃣ | fleur-de-lis | ⚜ |
| four | 4⃣ | free | 🆓 | gemini | ♊ |
| green-circle | 🟢 | green-square | 🟩 | grey-exclamation | ❕ |
| grey-question | ❔ | hash | #⃣ | heavy-check-mark | ✔ |
| heavy-division-sign | ➗ | heavy-dollar-sign | 💲 | heavy-equals-sign | 🟰 |
| heavy-minus-sign | ➖ | heavy-multiplication-x | ✖ | heavy-plus-sign | ➕ |
| high-brightness | 🔆 | id | 🆔 | ideograph-advantage | 🉐 |
| infinity | ♾ | information-source | ℹ | interrobang | ⁉ |
| keycap-ten | 🔟 | khanda | 🪯 | koko | 🈁 |
| large-blue-circle | 🔵 | large-blue-diamond | 🔷 | large-orange-diamond | 🔶 |
| latin-cross | ✝ | left-luggage | 🛅 | left-right-arrow | ↔ |
| leftwards-arrow-with-hook | ↩ | leo | ♌ | libra | ♎ |
| loop | ➿ | low-brightness | 🔅 | m | Ⓜ |
| male-sign | ♂ | medical-symbol | ⚕ | menorah | 🕎 |
| mens | 🚹 | mobile-phone-off | 📴 | name-badge | 📛 |
| negative-squared-cross-mark | ❎ | new | 🆕 | next-track-button | ⏭ |
| ng | 🆖 | nine | 9⃣ | no-bicycles | 🚳 |
| no-entry | ⛔ | no-entry-sign | 🚫 | no-mobile-phones | 📵 |
| no-pedestrians | 🚷 | no-smoking | 🚭 | non-potable-water | 🚱 |
| o | ⭕ | o2 | 🅾 | ok | 🆗 |
| om | 🕉 | on | 🔛 | one | 1⃣ |
| ophiuchus | ⛎ | orange-circle | 🟠 | orange-square | 🟧 |
| orthodox-cross | ☦ | parking | 🅿 | part-alternation-mark | 〽 |
| passport-control | 🛂 | pause-button | ⏸ | peace-symbol | ☮ |
| pisces | ♓ | place-of-worship | 🛐 | play-or-pause-button | ⏯ |
| potable-water | 🚰 | previous-track-button | ⏮ | purple-circle | 🟣 |
| purple-square | 🟪 | put-litter-in-its-place | 🚮 | question | ❓ |
| radio-button | 🔘 | radioactive | ☢ | record-button | ⏺ |
| recycle | ♻ | red-circle | 🔴 | red-square | 🟥 |
| registered | ® | repeat | 🔁 | repeat-one | 🔂 |
| restroom | 🚻 | rewind | ⏪ | sa | 🈂 |
| sagittarius | ♐ | scorpius | ♏ | secret | ㊙ |
| seven | 7⃣ | signal-strength | 📶 | six | 6⃣ |
| six-pointed-star | 🔯 | small-blue-diamond | 🔹 | small-orange-diamond | 🔸 |
| small-red-triangle | 🔺 | small-red-triangle-down | 🔻 | soon | 🔜 |
| sos | 🆘 | sparkle | ❇ | star-and-crescent | ☪ |
| star-of-david | ✡ | stop-button | ⏹ | symbols | 🔣 |
| taurus | ♉ | three | 3⃣ | tm | ™ |
| top | 🔝 | transgender-symbol | ⚧ | trident | 🔱 |
| twisted-rightwards-arrows | 🔀 | two | 2⃣ | u5272 | 🈹 |
| u5408 | 🈴 | u55b6 | 🈺 | u6307 | 🈯 |
| u6708 | 🈷 | u6709 | 🈶 | u6e80 | 🈵 |
| u7121 | 🈚 | u7533 | 🈸 | u7981 | 🈲 |
| u7a7a | 🈳 | underage | 🔞 | up | 🆙 |
| vibration-mode | 📳 | virgo | ♍ | vs | 🆚 |
| warning | ⚠ | wavy-dash | 〰 | wc | 🚾 |
| wheel-of-dharma | ☸ | wheelchair | ♿ | white-check-mark | ✅ |
| white-circle | ⚪ | white-large-square | ⬜ | white-medium-small-square | ◽ |
| white-medium-square | ◻ | white-small-square | ▫ | white-square-button | 🔳 |
| wireless | 🛜 | womens | 🚺 | x | ❌ |
| yellow-circle | 🟡 | yellow-square | 🟨 | yin-yang | ☯ |
| zero | 0⃣ |  |  |  |  |

## Travel & Places

| name | emoji | name | emoji | name | emoji |
| --- | --- | --- | --- | --- | --- |
| aerial-tramway | 🚡 | airplane | ✈ | alarm-clock | ⏰ |
| ambulance | 🚑 | anchor | ⚓ | articulated-lorry | 🚛 |
| artificial-satellite | 🛰 | auto-rickshaw | 🛺 | bank | 🏦 |
| barber | 💈 | beach-umbrella | 🏖 | bellhop-bell | 🛎 |
| bike | 🚲 | blue-car | 🚙 | boat | ⛵ |
| bricks | 🧱 | bridge-at-night | 🌉 | building-construction | 🏗 |
| bullettrain-front | 🚅 | bullettrain-side | 🚄 | bus | 🚌 |
| busstop | 🚏 | camping | 🏕 | canoe | 🛶 |
| car | 🚗 | carousel-horse | 🎠 | church | ⛪ |
| circus-tent | 🎪 | city-sunrise | 🌇 | city-sunset | 🌆 |
| cityscape | 🏙 | classical-building | 🏛 | clock1 | 🕐 |
| clock10 | 🕙 | clock1030 | 🕥 | clock11 | 🕚 |
| clock1130 | 🕦 | clock12 | 🕛 | clock1230 | 🕧 |
| clock130 | 🕜 | clock2 | 🕑 | clock230 | 🕝 |
| clock3 | 🕒 | clock330 | 🕞 | clock4 | 🕓 |
| clock430 | 🕟 | clock5 | 🕔 | clock530 | 🕠 |
| clock6 | 🕕 | clock630 | 🕡 | clock7 | 🕖 |
| clock730 | 🕢 | clock8 | 🕗 | clock830 | 🕣 |
| clock9 | 🕘 | clock930 | 🕤 | closed-umbrella | 🌂 |
| cloud | ☁ | cloud-with-lightning | 🌩 | cloud-with-lightning-and-rain | ⛈ |
| cloud-with-rain | 🌧 | cloud-with-snow | 🌨 | comet | ☄ |
| compass | 🧭 | construction | 🚧 | convenience-store | 🏪 |
| crescent-moon | 🌙 | cyclone | 🌀 | department-store | 🏬 |
| derelict-house | 🏚 | desert | 🏜 | desert-island | 🏝 |
| droplet | 💧 | earth-africa | 🌍 | earth-americas | 🌎 |
| earth-asia | 🌏 | european-castle | 🏰 | european-post-office | 🏤 |
| factory | 🏭 | ferris-wheel | 🎡 | ferry | ⛴ |
| fire | 🔥 | fire-engine | 🚒 | first-quarter-moon | 🌓 |
| first-quarter-moon-with-face | 🌛 | flight-arrival | 🛬 | flight-departure | 🛫 |
| flying-saucer | 🛸 | fog | 🌫 | foggy | 🌁 |
| fountain | ⛲ | fuelpump | ⛽ | full-moon | 🌕 |
| full-moon-with-face | 🌝 | globe-with-meridians | 🌐 | helicopter | 🚁 |
| hindu-temple | 🛕 | hospital | 🏥 | hotel | 🏨 |
| hotsprings | ♨ | hourglass | ⌛ | hourglass-flowing-sand | ⏳ |
| house | 🏠 | house-with-garden | 🏡 | houses | 🏘 |
| hut | 🛖 | japan | 🗾 | japanese-castle | 🏯 |
| kaaba | 🕋 | kick-scooter | 🛴 | last-quarter-moon | 🌗 |
| last-quarter-moon-with-face | 🌜 | light-rail | 🚈 | love-hotel | 🏩 |
| luggage | 🧳 | mantelpiece-clock | 🕰 | manual-wheelchair | 🦽 |
| metro | 🚇 | milky-way | 🌌 | minibus | 🚐 |
| monorail | 🚝 | moon | 🌔 | mosque | 🕌 |
| motor-boat | 🛥 | motor-scooter | 🛵 | motorcycle | 🏍 |
| motorized-wheelchair | 🦼 | motorway | 🛣 | mount-fuji | 🗻 |
| mountain | ⛰ | mountain-cableway | 🚠 | mountain-railway | 🚞 |
| mountain-snow | 🏔 | national-park | 🏞 | new-moon | 🌑 |
| new-moon-with-face | 🌚 | night-with-stars | 🌃 | ocean | 🌊 |


## dist_zef-lizmat-Text-Emoji.md
## Chunk 3 of 3
| office | 🏢 | oil-drum | 🛢 | oncoming-automobile | 🚘 |
| oncoming-bus | 🚍 | oncoming-police-car | 🚔 | oncoming-taxi | 🚖 |
| open-umbrella | ☂ | parachute | 🪂 | parasol-on-ground | ⛱ |
| partly-sunny | ⛅ | passenger-ship | 🛳 | pickup-truck | 🛻 |
| playground-slide | 🛝 | police-car | 🚓 | post-office | 🏣 |
| racing-car | 🏎 | railway-car | 🚃 | railway-track | 🛤 |
| rainbow | 🌈 | ring-buoy | 🛟 | ringed-planet | 🪐 |
| rock | 🪨 | rocket | 🚀 | roller-coaster | 🎢 |
| roller-skate | 🛼 | rotating-light | 🚨 | school | 🏫 |
| seat | 💺 | shinto-shrine | ⛩ | ship | 🚢 |
| skateboard | 🛹 | small-airplane | 🛩 | snowflake | ❄ |
| snowman | ⛄ | snowman-with-snow | ☃ | speedboat | 🚤 |
| stadium | 🏟 | star | ⭐ | star2 | 🌟 |
| stars | 🌠 | station | 🚉 | statue-of-liberty | 🗽 |
| steam-locomotive | 🚂 | stop-sign | 🛑 | stopwatch | ⏱ |
| sun-behind-large-cloud | 🌥 | sun-behind-rain-cloud | 🌦 | sun-behind-small-cloud | 🌤 |
| sun-with-face | 🌞 | sunny | ☀ | sunrise | 🌅 |
| sunrise-over-mountains | 🌄 | suspension-railway | 🚟 | synagogue | 🕍 |
| taxi | 🚕 | tent | ⛺ | thermometer | 🌡 |
| timer-clock | ⏲ | tokyo-tower | 🗼 | tornado | 🌪 |
| tractor | 🚜 | traffic-light | 🚥 | train | 🚋 |
| train2 | 🚆 | tram | 🚊 | trolleybus | 🚎 |
| truck | 🚚 | umbrella | ☔ | vertical-traffic-light | 🚦 |
| volcano | 🌋 | waning-crescent-moon | 🌘 | waning-gibbous-moon | 🌖 |
| watch | ⌚ | waxing-crescent-moon | 🌒 | wedding | 💒 |
| wheel | 🛞 | wind-face | 🌬 | wood | 🪵 |
| world-map | 🗺 | zap | ⚡ |  |  |

# INSPIRATION

Inspired by Simon Harms' [`Avolution::Emoji`](https://github.com/ukn-ubi/Avolution-Emoji) module, but completely re-imagined from scratch using the table provided by the [`gemoji`](https://github.com/github/gemoji) library.

# AUTHOR

Elizabeth Mattijsen [liz@raku.rocks](mailto:liz@raku.rocks)

Source can be located at: <https://github.com/lizmat/Text-Emoji> . Comments and Pull Requests are welcome.

If you like this module, or what I'm doing more generally, committing to a [small sponsorship](https://github.com/sponsors/lizmat/) would mean a great deal to me!

# COPYRIGHT AND LICENSE

Copyright 2024 Elizabeth Mattijsen

This library is free software; you can redistribute it and/or modify it under the Artistic License 2.0.