{"id":23579882,"url":"https://github.com/elixir-unicode/unicode_set","last_synced_at":"2025-04-04T22:04:23.626Z","repository":{"id":36327511,"uuid":"222572945","full_name":"elixir-unicode/unicode_set","owner":"elixir-unicode","description":"Unicode set parsing, expansion, macros and guards for Elixir","archived":false,"fork":false,"pushed_at":"2025-01-01T02:18:23.000Z","size":284,"stargazers_count":38,"open_issues_count":0,"forks_count":6,"subscribers_count":1,"default_branch":"main","last_synced_at":"2025-03-28T21:03:33.316Z","etag":null,"topics":[],"latest_commit_sha":null,"homepage":null,"language":"Elixir","has_issues":true,"has_wiki":null,"has_pages":null,"mirror_url":null,"source_name":null,"license":"other","status":null,"scm":"git","pull_requests_enabled":true,"icon_url":"https://github.com/elixir-unicode.png","metadata":{"files":{"readme":"README.md","changelog":"CHANGELOG.md","contributing":null,"funding":null,"license":"LICENSE.md","code_of_conduct":null,"threat_model":null,"audit":null,"citation":null,"codeowners":null,"security":null,"support":null,"governance":null,"roadmap":null,"authors":null,"dei":null,"publiccode":null,"codemeta":null}},"created_at":"2019-11-19T00:33:53.000Z","updated_at":"2025-01-01T02:18:26.000Z","dependencies_parsed_at":"2024-06-21T04:42:03.016Z","dependency_job_id":"02e93e18-b051-47a8-9655-1d28d056f830","html_url":"https://github.com/elixir-unicode/unicode_set","commit_stats":{"total_commits":167,"total_committers":8,"mean_commits":20.875,"dds":0.04790419161676651,"last_synced_commit":"4b77ded78b6faab3d7e3188bb5bd965f882e9f38"},"previous_names":[],"tags_count":20,"template":false,"template_full_name":null,"repository_url":"https://repos.ecosyste.ms/api/v1/hosts/GitHub/repositories/elixir-unicode%2Funicode_set","tags_url":"https://repos.ecosyste.ms/api/v1/hosts/GitHub/repositories/elixir-unicode%2Funicode_set/tags","releases_url":"https://repos.ecosyste.ms/api/v1/hosts/GitHub/repositories/elixir-unicode%2Funicode_set/releases","manifests_url":"https://repos.ecosyste.ms/api/v1/hosts/GitHub/repositories/elixir-unicode%2Funicode_set/manifests","owner_url":"https://repos.ecosyste.ms/api/v1/hosts/GitHub/owners/elixir-unicode","download_url":"https://codeload.github.com/elixir-unicode/unicode_set/tar.gz/refs/heads/main","host":{"name":"GitHub","url":"https://github.com","kind":"github","repositories_count":247256107,"owners_count":20909240,"icon_url":"https://github.com/github.png","version":null,"created_at":"2022-05-30T11:31:42.601Z","updated_at":"2022-07-04T15:15:14.044Z","host_url":"https://repos.ecosyste.ms/api/v1/hosts/GitHub","repositories_url":"https://repos.ecosyste.ms/api/v1/hosts/GitHub/repositories","repository_names_url":"https://repos.ecosyste.ms/api/v1/hosts/GitHub/repository_names","owners_url":"https://repos.ecosyste.ms/api/v1/hosts/GitHub/owners"}},"keywords":[],"created_at":"2024-12-26T23:13:10.421Z","updated_at":"2025-04-04T22:04:23.606Z","avatar_url":"https://github.com/elixir-unicode.png","language":"Elixir","funding_links":[],"categories":[],"sub_categories":[],"readme":"# Unicode Set\n\n![Build Status](https://api.cirrus-ci.com/github/elixir-unicode/unicode_set.svg)\n[![Hex.pm](https://img.shields.io/hexpm/v/unicode_set.svg)](https://hex.pm/packages/unicode_set)\n[![Hex.pm](https://img.shields.io/hexpm/dw/unicode_set.svg?)](https://hex.pm/packages/unicode_set)\n[![Hex.pm](https://img.shields.io/hexpm/l/unicode_set.svg)](https://hex.pm/packages/unicode_set)\n\nA [Unicode Set](https://unicode-org.github.io/icu/userguide/strings/unicodeset.html) is a representation of a set of Unicode characters or character strings. The contents of that set are specified by patterns or by building them programmatically. This library implements parsing of unicode sets, resolving them to a list of codepoints and matching a given codepoint to that list.  This expansion supports the following public API:\n\n* `Unicode.Set.match?/2` which is a macro that matches a codepoint to a unicode set.\n* `Unicode.Regex.compile/2` which pre-processes a regex string expanding unicode sets into a regex executable by the `Regex` module.\n* `Unicode.Set.to_utf8_char/1` that converts a unicode set into a form usable with [nimble_parsec](https://hex.pm/packages/nimble_parsec)\n* `Unicode.Set.compile_pattern/1` which converts a unicode set into a string that is then compiled with `:binary.compile_pattern/1`.\n\nThe implementation conforms closely to the [Unicode Set specification](https://unicode.org/reports/tr35/#Unicode_Sets) but currently omits support for the `\\N{codepoint_name}` syntax.\n\n\u003c!-- MDOC --\u003e\n\n## Usage\n\n### Function guards\n\nThis is helpful in defining [function guards](https://hexdocs.pm/elixir/patterns-and-guards.html#guards). For example:\n```elixir\ndefmodule Guards do\n  require Unicode.Set\n\n  # Define a guard that checks if a codepoint is a unicode digit\n  defguard digit?(x) when Unicode.Set.match?(x, \"[[:Nd:]]\")\nend\n\ndefmodule MyModule do\n  require Guards\n\n  # Define a function using the previously defined guard\n  def my_function(\u003c\u003c x :: utf8, _rest :: binary\u003e\u003e) when Guards.digit?(x) do\n    IO.puts \"Its a digit!\"\n  end\n\n  # Define a guard directly on the function\n  def my_other_function_(\u003c\u003c x :: utf8, _rest :: binary\u003e\u003e) when Unicode.Set.match?(x, \"[[:Nd:]]\") do\n    IO.puts \"Its also a digit!\"\n  end\nend\n```\n\n### Generating compiled patterns for String matching\n\n`String.split/3` and `String.replace/3` allow for patterns and [compiled patterns](http://erlang.org/doc/man/binary.html#compile_pattern-1) to be used with compiled patterns being the more performant approach.  Unicode Set supports the generation of patterns and compiled patterns:\n```elixir\niex\u003e pattern = Unicode.Set.compile_pattern!(\"[[:digit:]]\")\niex\u003e list = String.split(\"abc1def2ghi3jkl\", pattern)\n[\"abc\", \"def\", \"ghi\", \"jkl\"]\n```\n\n### Generating NimbleParsec ranges\n\nThe parser generator [nimble_parsec](https://hex.pm/packages/nimble_parsec) allows a list of codepoint ranges as parameters to several combinators. Unicode Set can generate such ranges:\n```\niex\u003e Unicode.Set.to_utf8_char!(\"[[^abcd][mnb]]\")\n[98, 109..110, {:not, 97..100}]\n```\nThis can be used as shown in the following example:\n```elixir\ndefmodule MyCombinators do\n  import NimbleParsec\n\n  @digit_list = Unicode.Set.to_utf8_char!(\"[[:digit:]]\")\n  def unicode_digit do\n    utf8_char(@digit_list)\n    |\u003e label(\"a digit in any Unicode script\")\n  end\nend\n```\n\n### Compiling extended regular expressions\n\nThe `Regex` module supports a limited set of Unicode Sets. The `Unicode.Regex` module provides `compile/2` and `compile!/2` functions that have the same arguments and compatible functionality with `Regexp.compile/2` other that they pre-process the regular expression, expanding any Unicode Sets. This makes it simple to incorporate Unicode Sets in regular expressions.\n\nAll Unicode Sets are expanded, even those that are known to `Regex.compile/2` since the erlang `:re` module upon `Regex` is based does not always keep pace with Unicode releases.\n\nFor example:\n\n```elixir\niex\u003e Unicode.Regex.compile(\"\\\\p{Zs}\")\n{:ok, ~r/[\\x{20}\\x{A0}\\x{1680}\\x{2000}-\\x{200A}\\x{202F}\\x{205F}\\x{3000}]/u}\n\niex\u003e Unicode.Regex.compile(\"[:graphic:]\")\n{:ok,\n ~r/[\\x{20}-\\x{7E}\\x{A0}-\\x{AC}\\x{AE}-\\x{377}\\x{37A}-\\x{37F}...]/u}\n```\n\n### Other Examples\n\nThese examples show how to combine sets (union, difference and intersection) to deliver a flexible targeting of the required match.\n\n```elixir\n# The character \"๓\" is the thai digit `1`\niex\u003e Unicode.Set.match? ?๓, \"[[:digit:]]\"\ntrue\n\n# Set operations allow union, insersection and difference\n# This example matches on digits, but not the Thai script\niex\u003e Unicode.Set.match? ?๓, \"[[:digit:]-[:thai:]]\"\nfalse\n```\n\n### Compile time parsing\n\nAs much work as possible is done at compile time in order to deliver good performance. The macro `Unicode.Set.match?/2` parses the unicode set, expands the require codepoints and generates guard clauses at compile time. The resulting code is a simple set of boolean operators that executes quickly at runtime.\n\n## Supported Unicode properties\n\nThis version of `Unicode Set` supports the following enumerable unicode properties in unicode sets:\n\n* `script` such as `[:script=arabic:]`, `\\p{script=arabic}` or `[:arabic:]`\n* `block` such as `[:block=sudanese:]`, `\\p{block=sudanese}`, `\\p{IsSudanese}` or `[:IsSudanese:]`\n* `general category` such as `[:Lu:]`, `\\p{Lu}`, `[:gc=Lu:]` or `[:general category=Lu:]`\n* `combining class` such as `[:ccc=230:]`\n\nIn addition, the following boolean properties are supported. These are expressed as `[:white space:]` or `\\p{White Space}`.\n\n\nProperty   | Property | Property | Property\n---------- | -------- | -------- | ----------\nalphabetic | ascii_hex_digit | bidi_control | cased\n changes_when_casemapped | changes_when_lowercased |  changes_when_titlecased | changes_when_uppercased\ndash | default_ignorable_code_point |  deprecated |  diacritic\nextender | grapheme_base |  grapheme_extend |  grapheme_link\nhex_digit | hyphen |  id_continue |  id_start\nideographic | ids_binary_operator |  ids_trinary_operator |  join_control\nlogical_order_exception | lowercase |  math |  noncharacter_code_point\nother_alphabetic | other_default_ignorable_code_point |  other_grapheme_extend |  other_id_continue\nother_id_start |  other_lowercase | other_math |  other_uppercase\npattern_syntax |  pattern_white_space | prepended_concatenation_mark |  quotation_mark\nradical |  regional_indicator | sentence_terminal |  soft_dotted\nterminal_punctuation |  unified_ideograph | uppercase |  variation_selector\nwhite_space |  xid_continue | xid_start | changes_when_casefolded\n\nIn all cases, property names and property values may include whitespace and mixed case notation.\n\n### General Categories\n\nAbbreviation\t      | Long Form\n------------------- | --------------------------------------\nL  |\tLetter\nLu |\tUppercase Letter\nLl |\tLowercase Letter\nLt |\tTitlecase Letter\nLm |\tModifier Letter\nLo |\tOther Letter\nM  |\tMark\nMn |\tNon-Spacing Mark\nMc |\tSpacing Combining Mark\nMe |\tEnclosing Mark\nN  |\tNumber\nNd |\tDecimal Digit Number\nNl |\tLetter Number\nNo |\tOther Number\nS  |\tSymbol\nSm |\tMath Symbol\nSc |\tCurrency Symbol\nSk |\tModifier Symbol\nSo |\tOther Symbol\nP  |\tPunctuation\nPc |\tConnector Punctuation\nPd |\tDash Punctuation\nPs |\tOpen Punctuation\nPe |\tClose Punctuation\nPi |\tInitial Punctuation\nPf |\tFinal Punctuation\nPo |\tOther Punctuation\nZ  |\tSeparator\nZs |\tSpace Separator\nZl |\tLine Separator\nZp |\tParagraph Separator\nC  |\tOther\nCc |\tControl\nCf |\tFormat\nCs |\tSurrogate\nCo |\tPrivate Use\nCn |\tUnassigned\n\nDerived Categories\t| Long Form\n------------------- | --------------------------------------\nAny                 | Any\tall code points\t[\\u{0}-\\u{10FFFF}]\nAssigned            | Assigned\tall assigned characters meaning\t`\\P{Cn}`\nASCII               | ASCII\tall ASCII characters\t[\\u{0}-\\u{7F}]\n\n### Compatibility Property Names\n\nProperty  | Unicode Category           | Comments\n--------- | -------------------------- | -----------\nalpha\t    | `\\p{Alphabetic}`           | Alphabetic includes more than gc = Letter. Note that combining marks (Me, Mn, Mc) are required for words of many languages. While they could be applied to non-alphabetics, their principal use is on alphabetics. Alphabetic should not be used as an approximation for word boundaries: see `word` below.\nlower\t    | `\\p{Lowercase}`\t             | Lowercase includes more than gc = Lowercase_Letter (Ll).\nupper\t    | `\\p{Uppercase}`\t             | Uppercase includes more than gc = Uppercase_Letter (Lu).\npunct\t    | `\\p{gc=Punctuation} \\p{gc=Symbol} - \\p{alpha}` | Punctuation and symbols.\ndigit     |\t`\\p{gc=Decimal_Number}`\t     | [0..9]\tNon-decimal numbers (like Roman numerals) are normally excluded.\nxdigit    | `\\p{gc=Decimal_Number} \\p{Hex_Digit}`\t| [0-9 A-F a-f]\tHex_Digit contains 0-9 A-F, fullwidth and halfwidth, upper and lowercase.\nalnum     |\t`\\p{alpha} \\p{digit}`\t       | Simple combination of other properties\nspace     |\t`\\p{Whitespace}`\t|\nblank\t    | `\\p{gc=Space_Separator} \\N{CHARACTER TABULATION}`\t| \"horizontal\" whitespace: space separators plus U+0009 tab.\ncntrl\t    | `\\p{gc=Control} `            | The characters in \\p{gc=Format} share some, but not all aspects of control characters. Many format characters are required in the representation of plain text.\ngraph\t    | `[^\\p{space} \\p{gc=Control} \\p{gc=Surrogate} \\p{gc=Unassigned}]`\t| Warning: the set shown here is defined by excluding space, controls, and so on with ^.\nprint\t    | `\\p{graph} \\p{blank} -- \\p{cntrl}`\t| Includes graph and space-like characters.\nword      | `\\p{alpha} \\p{gc=Mark} \\p{digit} \\p{gc=Connector_Punctuation} \\p{Join_Control}`\t|\tThis is only an approximation to Word Boundaries. The Connector Punctuation is added in for programming language identifiers, thus adding `_` and similar characters.\n\n## Additional Derived properties\n\nIn addition to the Unicode properties, some additional properties are also defined for convenience. These properties related to quote marks and are:\n\n* `quote_mark`\n* `quote_mark_left`\n* `quote_mark_right`\n* `quote_mark_ambidextrous`\n* `quote_mark_single`\n* `quote_mark_double`\n\nAs above these properties can be expressed in mixed case with spaces and underscores inserted for readability.  They can be used in the same way as any Unicode property name.\n\n## Example Unicode Sets\n\nHere are a few examples of sets. Although elements of the syntax appear similar to regular expressions, unicode sets only expresses one or more ranges of unicode codepoints.\n\nPattern\t              | Description\n--------------------- | -----------------------------------------------------------\n`[a-z]`               | The lower case letters `a` through `z`\n`[abc123]`            | The six characters `a,b,c,1,2` and `3`\n`[\\p{Letter}]`        | All characters with the Unicode General Category of Letter\n\n### String Values\n\nIn addition to being a set of characters (of Unicode code points), a UnicodeSet may also contain string values. Conceptually, the UnicodeSet is always a set of strings, not a set of characters, although in many common use cases the strings are all of length one, which reduces to being a set of characters.\n\nThis concept can be confusing when first encountered, probably because similar set constructs from other environments (regular expressions) can only contain characters.\n\n## Unicode Set Patterns\n\nPatterns are a series of characters bounded by square brackets that contain lists of characters and Unicode property sets. Lists are a sequence of characters that may have ranges indicated by a '-' between two characters, as in \"a-z\". The sequence specifies the range of all characters from the left to the right, in Unicode order. For example, `[a c d-f m]` is equivalent to `[a c d e f m]`. Whitespace can be freely used for clarity as `[a c d-f m]` means the same as `[acd-fm]`.\n\nUnicode property sets are specified by a Unicode property, such as [:Letter:]. For a list of supported properties, see the [Properties](#supported-unicode-properties) section. For details on the use of short vs. long property and property value names, see the end of this section. The syntax for specifying the property names is an extension of either POSIX or Perl syntax with the addition of `=value`. For example, you can match letters by using the POSIX syntax `[:Letter:]`, or by using the Perl-style syntax `\\p{Letter}`. The type can be omitted for the `Category` and `Script` properties, but is required for other properties.\n\nThe table below shows the two kinds of syntax: POSIX and Perl style. Also, the table shows the \"Negative\", which is a property that excludes all characters of a given kind. For example, `[:^Letter:]` matches all characters that are not `[:Letter:]`.\n\nStyle              | Positive\t        | Negative\n------------------ | ---------------- | ----------------\nPOSIX-style Syntax | [:type=value:]   |\t[:^type=value:]\nPerl-style Syntax  |\t\\p{type=value}\t| \\P{type=value}\n\nThese following low-level lists or properties then can be freely combined with the normal set operations (union, inverse, difference, and intersection):\n\nExample\t                       | Meaning\n------------------------------ | -----------------------------------------------------------\n`A B\t[[:letter:] [:number:]]` | To union two sets A and B, simply concatenate them\n`A \u0026 B\t[[:letter:] \u0026 [a-z]]`  | To intersect two sets A and B, use the '\u0026' operator.\n`A - B\t[[:letter:] - [a-z]]`\t | To take the set-difference of two sets A and B, use the '-' operator.\n`[^A]\t[^a-z]`\t                 | To invert a set A, place a `^` immediately after the opening `[`. Note that the complement only affects code points, not string values. In any other location, the `^` does not have a special meaning.\n\n## Precedence\n\nThe binary operators of union, intersection, and set-difference have equal precedence and bind left-to-right. Thus the following are equivalent:\n\n* `[[:letter:] - [a-z] [:number:] \u0026 [\\u0100-\\u01FF]]`\n* `[[[[[:letter:] - [a-z]] [:number:]] \u0026 [\\u0100-\\u01FF]]`\n\nAnother example is that the set `[[ace][bdf] - [abc][def]]` is not the empty set, but instead the set `[def]`. That is because the syntax corresponds to the following UnicodeSet operations:\n\n1. start with `[ace]`\n2. union `[bdf]`  -- we now have `[abcdef]`\n3. subtract `[abc]` -- we now have `[def]`\n4. union `[def]` -- no effect, we still have `[def]`\n\nThis only really matters where there are the difference and intersection operations, as the union operation is commutative. To make sure that the - is the main operator, add brackets to group the operations as desired, such as `[[ace][bdf] - [[abc][def]]]`.\n\nAnother caveat with the `\u0026` and `-` operators is that they operate between sets. That is, they must be immediately preceded and immediately followed by a set. For example, the pattern `[[:Lu:]-A]` is illegal, since it is interpreted as the set [:Lu:] followed by the incomplete range -A. To specify the set of uppercase letters except for `A`, enclose the `A` in a set: `[[:Lu:]-[A]]`.\n\n## Examples\n\n* `[a]`\tThe set containing 'a'\n* `[a-z]`\tThe set containing 'a' through 'z' and all letters in between, in Unicode order\n* `[^a-z]`\tThe set containing all characters but 'a' through 'z', that is, U+0000 through 'a'-1 and 'z'+1 through U+FFFF\n* `[[pat1][pat2]]`\tThe union of sets specified by pat1 and pat2\n* `[[pat1]\u0026[pat2]]`\tThe intersection of sets specified by pat1 and pat2\n* `[[pat1]-[pat2]]`\tThe asymmetric difference of sets specified by pat1 and pat2\n* `[:Lu:]`\tThe set of characters belonging to the given Unicode category; in this case, Unicode uppercase letters. The long form for this is `[:UppercaseLetter:]`.\n* `[:L:]`\tThe set of characters belonging to all Unicode categories starting with 'L', that is, `[[:Lu:][:Ll:][:Lt:][:Lm:][:Lo:]]`. The long form for this is `[:Letter:]`.\n\n## String Values in Sets\n\nString values are enclosed in `{`curly brackets`}`.\n\nSet expression\t    | Description\n------------------- | --------------------------------------\n`[abc{def}]`\t      | A set containing four members, the single characters a, b and c, and the string “def”\n`[{abc}{def}]`      |\tA set containing two members, the string “abc” and the string “def”.\n`[{a}{b}{c}][abc]`\t| These two sets are equivalent. Each contains three items, the three individual characters `a`, `b` and `c`. A `{string}` containing a single character is equivalent to that same character specified in any other way.\n\n## Character Quoting and Escaping in Unicode Set Patterns\n\n### Single Quote\n\nTwo single quotes represents a single quote, either inside or outside single quotes.\n\nText within single quotes is not interpreted in any way (except for two adjacent single quotes). It is taken as literal text (special characters become non-special).\n\nThese quoting conventions for ICU UnicodeSets differ from those of regular expression character set expressions. In regular expressions, single quotes have no special meaning and are treated like any other literal character.\n\n### Backslash Escapes\n\nOutside of single quotes, certain backslashed characters have special meaning. Note that these are escapes processed by Unicode Set (this library) and therefore require `\\\\\\\\` to be entered as a prefix. [Elixir also provides similar escapes](https://elixir-lang.org/getting-started/sigils.html#interpolation-and-escaping-in-sigils) as native part of its string processing and Elixir's escapes are to be preferred where possible.\n\nEscape         | Description\n-------------- | -------------------------------------------------\n\\uhhhh\t       | Exactly 4 hex digits; h in [0-9A-Fa-f]\n\\Uhhhhhhhh\t   | Exactly 8 hex digits\n\\xhh\t         | 1-2 hex digits\n\nCertain other escapes are native to Elixir and are applicable in Unicode Sets they are in any Elixir string:\n\nEscape         | Description\n-------------- | -------------------------------------------------\n\\a\t           | U+0007 (BELL)\n\\b\t           | U+0008 (BACKSPACE)\n\\t\t           | U+0009 (HORIZONTAL TAB)\n\\n\t           | U+000A (LINE FEED)\n\\v\t           | U+000B (VERTICAL TAB)\n\\f\t           | U+000C (FORM FEED)\n\\r\t           | U+000D (CARRIAGE RETURN)\n\\\\\t           | U+005C (BACKSLASH)\n\\xDD           | represents a single byte in hexadecimal (such as `\\x13`)\n\\uDDDD and \\u{D...} | represents a Unicode codepoint in hexadecimal (such as `\\u{1F600}`)\n\nAnything else following a backslash is mapped to itself, except in an environment where it is defined to have some special meaning. For example, `\\p{Lu}` is the set of uppercase letters in a Unicode Set.\n\nAny character formed as the result of a backslash escape loses any special meaning and is treated as a literal. In particular, note that `\\u` and `\\U` escapes create literal characters.\n\n### Whitespace\n\nWhitespace (as defined by the specification) is ignored unless it is quoted or backslashed.\n\n## Property Values\n\nThe following property value variants are recognized:\n\nFormat\t  | Example                           | Description\n--------- | --------------------------------- | ----------------------------------------------\nshort\t    | Lu                                | omits the type (used to prevent ambiguity and only allowed with the Category and Script properties)\nmedium\t  | gc=Lu                             | uses an abbreviated type and value\nlong\t    | General_Category=Uppercase_Letter | uses a full type and value\n\nIf the type or value is omitted, then the equals sign is also omitted. The short style is only\nused for Category and Script properties because these properties are very common and their omission is unambiguous.\n\nIn actual practice, you can mix type names and values that are omitted, abbreviated, or full. For example, if Category=Unassigned you could use what is in the table explicitly, `\\p{gc=Unassigned}`, `\\p{Category=Cn}`, or `\\p{Unassigned}`.\n\nWhen these are processed, case and whitespace are ignored so you may use them for clarity, if desired. For example, `\\p{Category = Uppercase Letter}` or `\\p{Category = uppercase letter}`.\n\n\u003c!-- MDOC --\u003e\n\n## Installation\n\nTo install, add the package `unicode_set` to your list of dependencies in `mix.exs`:\n\n```elixir\ndef deps do\n  [\n    {:unicode_set, \"~\u003e 1.0\"}\n  ]\nend\n```\n\nDocumentation can be found at [https://hexdocs.pm/unicode_set](https://hexdocs.pm/unicode_set).\n\n","project_url":"https://awesome.ecosyste.ms/api/v1/projects/github.com%2Felixir-unicode%2Funicode_set","html_url":"https://awesome.ecosyste.ms/projects/github.com%2Felixir-unicode%2Funicode_set","lists_url":"https://awesome.ecosyste.ms/api/v1/projects/github.com%2Felixir-unicode%2Funicode_set/lists"}