Image

head

code

root

para

L<Examples| file:../examples/index.podlite>


L<Download |file:../download/index.podlite>


React

=begin React :component<HeaderCol> :id<menu> 
=para L<Documentation|/doc/introduction>
=para L<Modules| /mods>
=para L<Examples| file:../examples/index.podlite>
=para L<Download |file:../download/index.podlite>
=para L<About|file:../about/index.podlite>
=para 🔍 K<⌘K>/K<ctrl-K>
=end React


HEADER

FOOTER

README

use v6.c;
unit class Unicode::Security:ver<0.0.2>;
use JSON::Fast;



my %confusables = from-json %?RESOURCES<data/confusables.json>.slurp;
my @confusables-sources; my @confusables-targets;

for %confusables.kv -> $key, @values {
    for @values -> $v {
        push @confusables-sources: $key;
        push @confusables-targets: $v;
    }
}

my %confusables-ws = from-json %?RESOURCES<data/confusables-ws.json>.slurp;
my %confusables-ws-sets;

for %confusables-ws.keys -> $key {
    for %confusables-ws{$key}.keys -> $k {
        %confusables-ws-sets{$key}{$k} = set %confusables-ws{$key}{$k}.list;
    }
}

sub confusables( $script where $script ∈ %confusables.keys ) is export {
    return %confusables{$script}
}

sub confusables-whole-script( $c where $c ∈ %confusables-ws.keys ) is export {
    return %confusables-ws{$c}
}

sub skeleton( $string ) is export {
    my $copy = $string.NFD.Str;
    $copy.=trans( @confusables-sources => @confusables-targets );
    return $copy
}

sub confusable( $this-string, $that-string ) is export {
    return skeleton( $this-string) eq skeleton( $that-string );
}

sub soss( $string ) is export is pure {
    my %soss;
    for $string.comb ->$c {
        my $script = $c.uniprop("Script") // "Unknown";
        %soss{$script}.push: $c if $script eq none("Common","Inherited");
    }
    return %soss;
}

sub whole-script-confusable( $target, $str ) is export {
    my $norm-target = $target.wordcase;
    my %soss = soss($str.NFD.Str) || return False;
    my @scripts = %soss.keys;
    return False if @scripts.elems > 1;
    my $source = @scripts.pop;
    my $char-set = %confusables-ws-sets{$source}{$norm-target};
    return True if $char-set ∩ %soss{$source}.list.Set;

}

sub mixed-script-confusable( $str ) is export {
    my %soss = soss($str.NFD.Str);
    for %soss.keys -> $source {
        my $sum = 0;
        for %soss.keys -> $target {
            next if $target eq $source;
            my $char-set = %confusables-ws-sets{$target}{$source};
            last unless $char-set ∩ %soss{$target}.list.Set; $sum++;
        }
        return True if 1 == ( %soss.keys.elems - $sum );
    }
    return False;
}

sub mixed-script ($str) is export { return 1 < soss $str; }



Unicode::Security - Check scripts for confusables and mixed script strings


=begin code :lang<perl6>

use v6.d;
use Unicode::Security;

say "Nope" if mixed-script( "abcdef" );
say "Yea" if mixed-script(
"aαbβ" );

say "Looks fake, Rick" if confusable('paypal',
				     "p\x[0430]yp\x[0430]l");
say "No problem" unless confusable('Paypal', 'paypal');

say "Not confusing" unless whole-script-confusable("Latin", "DFRVz");
say "Confusing" if whole-script-confusable("Cyrillic", "scope");

=end code


Unicode::Security is a (partial) transcription of its namesake Perl 5
module. It incorporates confusion tables from the Unicode consortium
to detect which graphemes can cause confusion between two alphabets,
or which strings could be confused between two or more alphabets; also
detect when some strings have mixed scripts, which can be used to slip
by literal-string detectors.


The list of confusables is generated from the list published by the
unicode consortium using the scripts in C<resources/script>. You
should have received a copy along with this. The scripts generate two
JSON files, which must be moved by hand to the C<resources/data>
		  directory. You don't need to do this unless you're certain that the
		  supplied copy is I<really> out of sync with the real
		  ones.


Returns true if one string could be confusable for the other.


sub whole-script-confusable( $script, $string )


Returns True if the string would be confusable for another written in the indicated script


Returns C<True> if the string includes several scripts, C<False> otherwise


Returns C<True> if the scripts present in a string could make it confusable for any of them. 


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


Security

# code (almost) verbatim from Rakudo source
my constant $UNICODE-VERSION = (
   '1.1' => 'a',
   '2.0' => 'ẛ',
   '2.1' => '€',
   '3.0' => 'ϟ',
   '3.1' => 'ϴ',
   '3.2' => '⁇',
   '4.0' => 'ȡ',
   '4.1' => 'ℼ',
   '5.0' => 'ↄ',
   '5.1' => 'Ϗ',
   '5.2' => 'Ɒ',
   '6.0' => '✅',
   '6.1' => 'Ɦ',
   '6.2' => '₺',
   '6.3' =>  0x061C.chr,
   '7.0' =>  0x037F.chr,
   '8.0' =>  0x218A.chr,
   '9.0' =>  0xA7AE.chr,
  '10.0' =>  0x20BF.chr,
  '11.0' =>  0xA7AF.chr,
  '12.0' =>  0xA7BA.chr,
  '12.1' =>  0x32FF.chr,
  '13.0' => 0x1F972.chr,
  '14.0' =>  0x061D.chr,
  '15.0' =>  0x0CF3.chr,
# PLEASE ADD NEWER UNICODE VERSIONS HERE, AS SOON AS THE UNICODE
# CONSORTIUM HAS RELEASED A NEW VERSION
).first(*.value.uniprop('Age') ne 'Unassigned', :end).key.Version;

sub EXPORT () {
    Map.new: '$?UNICODE-VERSION' => $UNICODE-VERSION
}



UNICODE-VERSION - Provide $?UNICODE-VERSION for older Raku versions


=begin code :lang<raku>

use UNICODE-VERSION;

say $?UNICODE-VERSION;  # v13.0  e.g.

=end code


UNICODE-VERSION checks the unicode database at compile time for
certain marker codepoints that got added at certain unicode versions
and exports a C<%?UNICODE-VERSION> C<Version> constant that indicates
the version of Unicode that is currently being supported, as determined
by those codepoints.


Source can be located at: https://github.com/lizmat/UNICODE-VERSION .
Comments and Pull Requests are welcome.


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


UNICODE-VERSION

The Raku Knowledge Base


=begin React :component<HeaderCol> :id<footer>  
=begin nested :!nested
=item1 B<Language>
    =item2 L<Get started|file:../getting-started/getting-started.podlite>
    =item2 L<Why Raku?|/doc/language/faq#Why-should-I-learn-Raku-What's-so-great-about-it>
    =item2 L<Try Raku|https://glot.io/new/raku>
    =item2 L<Raku cheat sheet|https://github.com/Raku/mu/blob/master/docs/Perl6/Cheatsheet/cheatsheet.txt>
    =item2 L<empty|#>
    =item2 L<empty|#>
    =item2 L<empty|#>
    =item2 L<Raku on Exercism|https://exercism.org/tracks/raku>
    =item2 L<Wikipedia|https://en.wikipedia.org/wiki/Raku_(programming_language)>
    =item2 L<empty|#>
    =item2 L<empty|#>
    =item2 L<empty|#>

=end nested
=begin nested :!nested

=item1 B<L<Documentation|/doc>>
    =item2 L<Getting started, Migration guides from other languages, & Tutorials | file:../doc/introduction.podlite>
    =item2 L<Language References|file:../doc/reference.podlite>
    =item2 L<Type Reference| file:../doc/types.podlite>
    =item2 L<Miscellaneous| file:../doc/miscellaneous.podlite>
    =item2 L<FAQs (Frequently Asked Questions)|/doc/language/faq>
    =item2 L<Community|/doc/language/community>
    =item2 L<The list of all documents|file:../doc/index.podlite>

=item1 B<Resources>
    =item2 L<The Raku Guide|https://raku.guide/>
    =item2 L<Books |https://perl6book.com/>
    =item2 L<Rosetta Code | https://www.raku.org/community/rosettacode>

=end nested
=begin nested :!nested

=item1 B<Resoures>
    =item2 L<Download | file:../download/index.podlite>
    =item2 L<empty|#>
    =item2 L<empty|#>
    =item2 L<empty|#>
    =item2 L<empty|#>
    =item2 L<empty|#>
    =item2 L<empty|#>
    =item2 L<empty|#>

=item1 B<Learning>
    =item2 L<The Raku Guide|https://raku.guide/>
    =item2 L<Wikibook |https://en.wikibooks.org/wiki/Raku_Programming>
    =item2 L<Books |https://perl6book.com/>
    =item2 L<Rosetta Code | https://www.raku.org/community/rosettacode>
    =item2 L<Learn Raku in Y minutes|https://learnxinyminutes.com/docs/raku/>
    =item2 L<Golfing |https://github.com/AlexDaniel/raku-golf-cheatsheet>
=end nested
=begin nested :!nested

=item1 B<Explore>
    =item2 L<Raku Blog Aggregator|https://planet.raku.org/>
    =item2 L<Rakudo Weekly|https://rakudoweekly.blog/>
    =item2 L<The Weekly Challenge |https://perlweeklychallenge.org/>
    =item2 L<Raku Advent Calendar|https://raku-advent.blog/>
    =item2 L<empty|#>
    =item2 L<empty|#>
    =item2 L<empty|#>
    =item2 L<empty|#>
    =item2 L<empty|#>

=end nested
=end React


=begin React :component<CookieConsent> :id<CookieConsent> :buttonCaption("Got it!")
=para
This website uses cookies for analytics.
=end React


README

NAME

SYNOPSIS

DESCRIPTION

AUTHOR

COPYRIGHT AND LICENSE

UNICODE-VERSION v0.0.1

Authors

License

Dependencies

Test Dependencies

Provides

Documentation