########################################################################
# Define a list of symbols, all of whose glyphs are nearly identical.  #
# An exemplar glyph will be selected for each item, which will be      #
# listed only once in the index.                                       #
#                                                                      #
# Author: Scott Pakin <scott+clsl@pakin.org>                           #
########################################################################

[[merge]]
matches = [
    "actuarial angle",
    "Admetos",
    "aleph",
    "anaclasis",
    "anger",
    "ankh",
    "antisigma",
    "Apple",
    "Aquarius",
    "arc",
    "Aries",
    "artist",
    "ascending node",
    "at sign",
    "bag membership",
    "Baha'i",
    "baht",
    "barcode",
    "beth",
    "between",
    "BlackBerry",
    "bottom",
    "bouncing ball",
    "bra",
    "bullet",
    "Cancer",
    "caron",
    "catalexis",
    "cauldron",
    "cedilla",
    "Ceres",
    "chestnut",
    "choice",
    "complement",
    "convolution",
    "coproduct",
    "copyright",
    "corresponds",
    "currency",
    "daleth",
    "Debian",
    "degree",
    "descending node",
    "diameter",
    "divorced",
    "Docker",
    "Dropbox",
    "edit",
    "emgma",
    "enya",
    "Erlang",
    "estimated",
    "factory worker",
    "feeding baby",
    "flap",
    "for all",
    "franc",
    "game",
    "gesturing NO",
    "gesturing OK",
    "gimel",
    "group objects",
    "Grunt",
    "Hacker News",
    "hamster",
    "handball",
    "health worker",
    "Hermitian conjugate matrix",
    "intercalate",
    "interleave",
    "iteration",
    "Java",
    "JavaScript",
    "Jedi Order",
    "Juno",
    "Jupiter",
    "k",
    "ket",
    "kidney",
    "language",
    "lari",
    "Leo",
    "Libra",
    "lifting weights",
    "line feed",
    "log in",
    "log out",
    "mage",
    "Magento",
    "married",
    "Mars",
    "Mercury",
    "moo",
    "multimap",
    "musical score",
    "nabla",
    "network",
    "no bicycles",
    "no entry",
    "no mobile phones",
    "no pedestrians",
    "Node.js",
    "npm",
    "octagon",
    "office worker",
    "ogonek",
    "opposition",
    "Pallas",
    "panel layouts",
    "partial derivative",
    "permyriad",
    "pfund",
    "Pisces",
    "podcast",
    "police officer",
    "Poseidon",
    "prime",
    "pull back",
    "push out",
    "Python",
    "quincunx",
    "raising hand",
    "Raspberry Pi",
    "recipe",
    "redo",
    "reference",
    "respondens",
    "ruble",
    "Sagittarius",
    "Sass",
    "Saturn",
    "Scala",
    "schwa",
    "Scorpio",
    "section mark",
    "semisextile",
    "sesquiquadrate",
    "sextile",
    "sha",
    "sign in",
    "sign out",
    "slice",
    "smash product",
    "sunglasses",
    "SUSE",
    "Symfony",
    "sync",
    "Taurus",
    "tipping hand",
    "undo",
    "Unity",
    "Virgo",
    "voicemail",
    "Vulcanus",
    "wagon",
    "watch",
    "water polo",
    "Weierstrass elliptic function",
    "wreath product",
    "yen",
    "Zenodo",
    "Zeus"
]

# Top-level entries, all of whose subentries should be independently
# merged, and top-level "see..." entries.
[[merge]]
consider_all_entries = true
top_matches = [
    "accents",
    "alla breve",
    "align text",
    "ampersand",
    "antiquark",
    "approximately equivalent to",
    "arc",
    "assumption",
    "asymptotically equal to",
    "backslash",
    "barred letters",
    "battery",
    "because",
    "blackboard bold letters",
    "bottom",
    "boxed symbols",
    "bunch join",
    "bunch meet",
    "camel",
    "car",
    "cardinality",
    "Cartesian product",
    "cell phone",
    "chain",
    "chess",
    "chevron",
    "circled symbols",
    "clefs",
    "Closed Access",
    "closed captioning",
    "closure",
    "cocktail",
    "coherence",
    "colon",
    "comedy and tragedy",
    "common time",
    "coordinate axes",
    "copyleft",
    "cross product",
    "curly pi",
    "cutoff subtraction",
    "dal segno",
    "delimiters",
    "derivative, partial",
    "Descartes's equal sign",
    "diaeresis",
    "diagonal line",
    "diamond",
    "differential, inexact",
    "digital signals",
    "dominance",
    "dot",
    "eighth note",
    "element of",
    "ellipse",
    "ellipsis",
    "empty set",
    "engma",
    "entailment",
    "entails",
    "equilibrium",
    "esh",
    "euro",
    "evaluated at",
    "excess",
    "exists",
    "falsum",
    "Father Christmas",
    "fermata",
    "fighter jet",
    "fish tail",
    "fishhook",
    "flat",
    "footline",
    "free",
    "function",
    "gender signs",
    "geometric proportion",
    "glottal stop",
    "Go stones",
    "grid",
    "half note",
    "hamsa",
    "heartbeat",
    "highlighter",
    "horizontal line",
    "i",
    "iff",
    "implication",
    "in",
    "incoherence",
    "inexact differential",
    "integral",
    "interior",
    "interior product",
    "Islam",
    "j",
    "jigsaw puzzle",
    "join (database)",
    "justice",
    "kernel contraction",
    "keyboard",
    "landmark",
    "lattice",
    "leads to",
    "ligatures",
    "linear implication",
    "logical negation",
    "lollipop (mathematics)",
    "long-legged letters",
    "loudspeaker",
    "map join",
    "map marker",
    "map meet",
    "maps to",
    "marcato",
    "marker",
    "martini",
    "member of",
    "merge",
    "micro",
    "millesimal sign",
    "models",
    "multimap",
    "multiplication",
    "multiplicative disjunction",
    "mute",
    "nand",
    "negation",
    "nonbinary",
    "octothorpe",
    "ohm",
    "ordinal",
    "orthogonal",
    "overline",
    "owns",
    "paper airplane",
    "par",
    "parallel",
    "parentheses",
    "pentagram",
    "period",
    "per mill",
    "perpendicular",
    "per ten thousand",
    "per thousand",
    "phonetic accents",
    "pipe",
    "pipette",
    "pitchfork",
    "pomega",
    "postal mark",
    "pound sign",
    "prime",
    "proper subset",
    "proper superset",
    "proportion",
    "quark",
    "quarter note",
    "radiation",
    "ratio",
    "rays",
    "rectangle",
    "registered trademark",
    "restriction",
    "reversed letters",
    "reverse solidus",
    "ring buoy",
    "rubber stamp",
    "s",
    "satisfies",
    "semicolon",
    "semidirect product",
    "send email",
    "set difference",
    "set interior",
    "set intersection",
    "set membership",
    "set union",
    "Sheffer's stroke",
    "show",
    "shuffle product",
    "signal",
    "since",
    "sixteenth note",
    "sixty-fourth note",
    "slash",
    "small caps letters",
    "solidus",
    "space",
    "steel",
    "storm",
    "strict converse implication",
    "strict implication",
    "stroked letters",
    "sum",
    "swimming pool",
    "swung dash",
    "tack",
    "tautology",
    "telephone handset",
    "ten thousandths",
    "theater masks",
    "therefore",
    "thirty-second note",
    "thorn",
    "thousandths",
    "thus",
    "trademark",
    "traffic signal",
    "transgender",
    "transversal intersection",
    "triangle",
    "turnstile",
    "universal bunch quantifier",
    "universal individual quantifier",
    "vee",
    "vertical bar",
    "vinculum",
    "wedge",
    "whole note",
    "wifi",
    "Windows",
    "Y",
    "yogh",
    "Z notation",
    "zoom"
]

[[merge]]
top_matches = "dice"
matches = "3D"
render_contains = '\usym'

[[merge]]
top_matches = "dice"
matches = "dice"

[[merge]]
top_matches = "cat"
not_matches = "cat"

[[merge]]
consider_all_entries = true
top_matches = "save"
format_contains = 'hyperindexformat{\see{floppy disk'

# This rule should precede the following one.
[[merge]]
top_contains = "pilcrow"
render_contains = ['\DCd', '\STIXmathparagraph']

[[merge]]
top_contains = "pilcrow"
not_render_contains = ['\textpilcrow', '\usym{2761}']

[[merge]]
top_matches = "emoji"
matches = "modifiers"

[[merge]]
top_matches = "jack-o'-lantern"
render_contains = ["bigpumpkin", "greatpumpkin"]

[[merge]]
top_matches = "microphone"
render_contains = ['\tiMicrophone', '\faMicrophone']

[[merge]]
top_matches = "keyboard symbols"
matches = "delete"

[[merge]]
top_matches = "keyboard symbols"
matches = "command"

[[merge]]
top_matches = "airplane"
matches = "landing"

[[merge]]
top_matches = "airplane"
matches = "taking off"

[[merge]]
top_matches = "airplane"
matches = "paper"
render_contains = [
    '(\lucideicon{send})',
    '(\lucideicon{send-horizontal})',
    '(\faPaperPlane[regular])'
]

[[merge]]
top_matches = "house"
not_matches = "house"

[[merge]]
consider_all_entries = true
top_matches = "sword"
matches = "multiple, crossed"

[[merge]]
top_matches = "dagger"
not_render_contains = ["1f5e1", "1F5E1"]

[[merge]]
top_matches = "calendar"
prefix = "with"

[[merge]]
top_matches = "leaf"
matches = "maple"

[[merge]]
top_matches = "leaf"
matches = "fleuron"

[[merge]]
render_contains = ['$\ell$', '\STIXell']

[[merge]]
top_matches = "yin-yang"
not_render_contains = '\twemoji{262f}'

[[merge]]
top_regex = '^[A-Z]+!* with arrow$'

[[merge]]
top_matches = "store"
matches = "slashed"

[[merge]]
top_matches = "dangerous bend"
render_contains = ['\dbend', '\textdbend']

[[merge]]
top_matches = "dangerous bend"
render_contains = ['\lhdbend', '\textlhdbend']

[[merge]]
top_matches = "dangerous bend"
render_contains = ['\reversedvideodbend', '\textreversedvideodbend']

[[merge]]
top_matches = "construction worker"
render_contains = '\twemoji{1f477'

[[merge]]
consider_all_entries = true
top_matches = "feet"
render_contains = "prime"

[[merge]]
consider_all_entries = true
top_matches = "feet"
render_contains = ["SingleQuote", "textquotesingle"]

[[merge]]
consider_all_entries = true
top_matches = "inches"
render_contains = ["DoubleQuote", "textquotedbl"]

[[merge]]
top_matches = "quotation marks"
prefix = "straight"

[[merge]]
consider_all_entries = true
top_matches = "ditto marks"

[[merge]]
top_matches = "rowing"
render_contains = '\twemoji{1f6a3'

[[merge]]
top_regex = '^\d+$'
matches = "old style"

[[merge]]
top_matches = "underline"
not_render_contains = '\faUnderline'

[[merge]]
top_matches = "times"

[[merge]]
consider_all_entries = true
format_contains = 'gender signs'

[[merge]]
top_matches = "handshake"
matches = "slashed"

[[merge]]
top_regex = '^\d+$'
matches = "circled, filled"

[[merge]]
top_matches = "hash"
render_contains = ['($\ABXhash$)', '(\BSKhash)']

[[merge]]
top_matches = "hash"
render_contains = [
    '($\ABXvarhash$)',
    '(\#)',
    '(\BSKvarhash)',
    '(\Numbr)',
    '(\faHashtag)',
    '(\lucideicon{hash})'
]

[[merge]]
consider_all_entries = true
top_matches = "number sign"
not_render_contains = "textnumero"

[[merge]]
top_matches = "l"
matches = "with belt"

[[merge]]
top_matches = "l"
matches = "with tilde"

[[merge]]
top_matches = "diacritics"
matches = "apostrophe, reversed"

[[merge]]
top_matches = "diacritics"
matches = "secondary stress"

[[merge]]
consider_all_entries = true
top_matches = "diacritics"
matches = "hat"

[[merge]]
consider_all_entries = true
top_matches = "diacritics"
matches = "tilde"

[[merge]]
top_matches = "asterisk"
not_matches = "dingbat"

[[merge]]
top_matches = "sharp"
matches = "sharp"

[[merge]]
top_matches = "natural"
not_render_contains = '\EOna'

[[merge]]
top_matches = ["2", "3"]
matches = "rotated"

[[merge]]
compare_lowercase = true
top_matches = "end of proof"
render_contains = "qed"

[[merge]]
top_matches = "hammer"
matches = "and sickle"

[[merge]]
top_matches = "trash"
matches = "restore from"

[[merge]]
top_matches = "conjunction"
matches = "astronomical"

[[merge]]
consider_all_entries = true
top_matches = "copyright"

[[merge]]
top_matches = "knife"
matches = "athame"

[[merge]]
top_matches = "Venus"
not_render_contains = '\SMBTvenusfigure'

[[merge]]
top_matches = "Skype"
render_contains = ['(\faSkype)', '(\tiSocialSkype)']

[[merge]]
top_matches = "biohazard"
render_contains = [
    '(\AREVbiohazard)',
    '(\Biohazard)',
    '(\faBiohazard)'
]

[[merge]]
top_matches = "sparkle"
render_contains = [
    '(\SparkleBold)',
    '(\Sparkle)',
    '(\usym{2747})',
    '(\usym{2748})'
]

[[merge]]
top_matches = "bell"
render_contains = [
    '(\bell)',
    '(\faBell)'
]

[[merge]]
top_matches = "bell"
render_contains = [
    '(\tiBell)',
    '(\usym{1F514})',
    '(\usym{1F56D})'
]

[[merge]]
top_matches = "lightning"
render_contains = [
    '($\PDFMSYMlightning$)',
    '($\lightning$)',
    '(\FDSYMlightning)',
    '(\Lightning)',
    '(\MNSlightning)'
]

[[merge]]
top_matches = "wind"
render_contains = [
    '(\faWind)',
    '(\lucideicon{wind})'
]

[[merge]]
top_matches = "ORCID"
render_contains = ['(\aiOrcid)', '(\faOrcid)']

[[merge]]
top_matches = "astronaut"
render_contains = '200d-1f680'

[[merge]]
top_matches = "window"
render_contains = ['(\faSquareXmark)', '(\faRectangleXmark)']

[[merge]]
top_matches = "paper"
matches = "acid-free"

[[merge]]
top_matches = "backspace"
render_contains = ['(\faDeleteLeft)', '(\tiBackspace)']

[[merge]]
top_matches = "om"
render_contains = ['\faOm', '\usym{1F549}']

[[merge]]
consider_all_entries = true
top_matches = "tower"
matches = "Tokyo"

[[merge]]
top_matches = "peace"
render_contains = ['\bcpeaceandlove', '\faPeace', '\usym{262E}']

[[merge]]
top_matches = "rod of Asclepius"
render_contains = ['\dsmedical', '\usym{2695}']

[[merge]]
top_matches = "book"
render_contains = [
   '\usym{1F4D7}',
   '\usym{1F4D8}',
   '\usym{1F4D9}'
]

[[merge]]
top_matches = "warning"
render_contains = [
    '(\AREVwarning)',
    '(\lucideicon{triangle-alert})',
    '(\tiWarningOutline)',
    '(\usym{26A0})',
    '(\warning)'
]

[[merge]]
top_matches = "warning"
render_contains = ['(\faTriangleExclamation)', '(\tiWarning)']

[[merge]]
top_matches = "guillemet"
matches = "decorative"

[[merge]]
top_matches = "Gemini"
render_contains = [
    '($\ABXGemini$)',
    '(\Gemini)',
    '(\SMBTgemini)',
    '(\STARGemini)',
    '(\gemini)',
    '\usym{264A}'
]

[[merge]]
top_matches = "no"
render_contains = [
    '(\asapNotSign)',
    '(\faBan)',
    '(\lucideicon{ban})',
    '(\usym{1F6C7})'
]

[[merge]]
top_matches = "shield"
render_contains = ['\lucideicon{shield-ban}', '\lucideicon{shield-off}']

[[merge]]
top_matches = "pencil"
render_contains = [
    '\Pencil',
    '\usym{270E}',
    '\usym{270F}',
    '\usym{2710}',
    '\smallpencil'
]

[[merge]]
top_matches = "cellular signal"
render_contains = ['(\faSignal)', '(\lucideicon{signal})']

[[merge]]
top_matches = "waves"
render_contains = [
    '(\faWater)',
    '(\lucideicon{waves})'
]

[[merge]]
top_matches = "Bluetooth"
render_contains = [
    '(\faBluetoothB)',
    '(\lucideicon{bluetooth})'
]

[[merge]]
matches = "code"
render_contains = [
    '(\faCode)',
    '(\lucideicon{code-xml})'
]

[[merge]]
matches = "scales"
render_contains = [
    '(\dsjuridical)',
    '(\usym{2696})'
]

[[merge]]
matches = "scales"
render_contains = [
    '(\faScaleBalanced)',
    '(\lucideicon{scale})'
]

[[merge]]
top_matches = "stethoscope"
render_contains = [
    '(\faStethoscope)',
    '(\lucideicon{stethoscope})'
]

[[merge]]
top_matches = "information"
render_contains = [
    '(\asapInformationSign)',
    '(\lucideicon{info})',
    '(\usym{1F6C8})'
]

[[merge]]
top_matches = "information"
render_contains = [
    '(\Info)',
    '(\chinaInfo)'
]

[[merge]]
top_matches = "loop"
render_contains = [
    '(\twemoji{27b0})',
    '(\usym{27B0})'
]

[[merge]]
top_matches = "radioactive"
render_contains = [
    '(\AREVradiation)',
    '(\usym{2622})'
]

[[merge]]
top_matches = "radioactive"
render_contains = [
    '(\Radiation)',
    '(\Radioactivity)',
    '(\faRadiation)'
]


[[merge]]
top_matches = "rainbow"
render_contains = [
    '(\faRainbow)',
    '(\lucideicon{rainbow})'
]

#-------------------------------- suns --------------------------------

[[merge]]
top_matches = "sun"
matches = "astronomical"

[[merge]]
top_matches = "sun"
render_contains = [
    '\STIXsun',
    '(\usym{263C})',
    '(\ifsSun)',
    '(\sun)',
    '(\SI)',
    '(\SMBTsunrays)',
    '(\SMBTsunwithrays)',
    '(\tiWeatherSunny)'
]

[[merge]]
top_matches = "sun"
matches = "behind cloud"
render_contains = [
    '(\usym{1F325})',
    '(\usym{26C5})'
]

# ------------------------------ scissors ------------------------------

[[merge]]
top_matches = "scissors"
render_contains = [
    '(\CutLeft)',
    '(\CutRight)'
]

[[merge]]
top_matches = "scissors"
render_contains = [
    '(\LeftScissors)',
    '(\RightScissors)',
    '(\ScissorsLeft)',
    '(\ScissorsRight)',
    '(\ScissorLeft)',
    '(\ScissorRight)',
    '(\usym{2700})',
    '(\usym{2702})'
]

[[merge]]
top_matches = "scissors"
render_contains = [
    '(\ScissorHollowLeft)',
    '(\ScissorHollowRight)',
    '(\usym{2704})'
]

[[merge]]
top_matches = "scissors"
render_contains = [
    '(\lucideicon{square-bottom-dashed-scissors})',
    '(\lucideicon{square-scissors})'
]

[[merge]]
top_matches = "scissors"
render_regex = '(\\Scissor(Left|Right)Broken(Top|Bottom))|\\usym\{270[13]\}'

[[merge]]
top_matches = "scissors"
render_contains = [
    '(\faScissors)',
    '(\lucideicon{scissors})'
]

# ----------------------------- restrooms ------------------------------

[[merge]]
top_matches = "restroom"
render_contains = [
    '(\Gentsroom)',
    '(\usym{1F6B9})'
]

[[merge]]
top_matches = "restroom"
render_contains = [
    '(\Ladiesroom)',
    '(\usym{1F6BA})'
]

[[merge]]
top_matches = "restroom"
render_contains = [
    '(\faRestroom)',
    '(\usym{1F6BB})'
]

# ----------------------- media control symbols ------------------------

[[merge]]
top_matches = "media control symbols"
matches = "forward"
render_contains = [
    '(\ForwardToIndex)',
    '(\faForwardFast)'
]

[[merge]]
top_matches = "media control symbols"
matches = "forward"
render_contains = [
    '(\ForwardToEnd)',
    '(\faForwardStep)'
]

[[merge]]
top_matches = "media control symbols"
matches = "forward"
render_contains = [
    '(\faForward)',
    '(\tiMediaFastForward)'
]

[[merge]]
top_matches = "media control symbols"
matches = "forward"
render_contains = [
    '(\tiMediaFastForwardOutline)',
    '(\lucideicon{fast-forward})'
]

[[merge]]
top_matches = "media control symbols"
matches = "play"
render_contains = [
    '(\tiMediaPlay)',
    '(\faPlay)'
]

[[merge]]
top_matches = "media control symbols"
matches = "play"
render_contains = [
    '(\lucideicon{play})',
    '(\tiMediaPlayOutline)'
]

[[merge]]
top_matches = "media control symbols"
matches = "power"
render_contains = [
    '(\lucideicon{power})',
    '(\tiPower)',
    '(\faPowerOff)'
]

[[merge]]
top_matches = "media control symbols"
matches = "repeat"
render_contains = [
    '(\lucideicon{repeat})',
    '(\faRepeat)'
]

[[merge]]
top_matches = "media control symbols"
matches = "reverse"
render_contains = [
    '(\RewindToIndex)',
    '(\faBackwardFast)'
]

[[merge]]
top_matches = "media control symbols"
matches = "reverse"
render_contains = [
    '(\RewindToStart)',
    '(\faBackwardStep)'
]

[[merge]]
top_matches = "media control symbols"
matches = "reverse"
render_contains = [
    '(\Rewind)',
    '(\tiMediaPlayReverse)'
]

[[merge]]
top_matches = "media control symbols"
matches = "reverse"
render_contains = [
    '(\tiMediaRewindOutline)',
    '(\lucideicon{rewind})'
]

[[merge]]
top_matches = "media control symbols"
matches = "reverse"
render_contains = [
    '(\faBackward)',
    '(\tiMediaRewind)'
]

[[merge]]
top_matches = "media control symbols"
matches = "stop"
render_contains = [
    '(\tiMediaStop)',
    '(\faStop)'
]

[[merge]]
top_matches = "media control symbols"
matches = "pause"
render_contains = [
    '(\lucideicon{circle-pause})',
    '(\faCirclePause[regular])'
]

[[merge]]
top_matches = "media control symbols"
matches = "pause"
render_contains = [
    '(\lucideicon{pause})',
    '(\tiMediaPauseOutline)'
]

[[merge]]
top_matches = "media control symbols"
matches = "pause"
render_contains = [
    '(\tiMediaPause)',
    '(\faPause)'
]

# ----------------------------- envelopes ------------------------------

[[merge]]
top_matches = "envelope"
matches = "with lightning"

[[merge]]
top_matches = "envelope"
matches = "with downward arrow"

[[merge]]
top_matches = "envelope"
render_contains = [
    '(\Letter)',
    '(\Postbox)',
    '(\asapEnvelope)',
    '(\faEnvelope[regular])',
    '(\ifsLetter)',
    '(\tiMail)',
    '(\usym{1F582})'
]

# ---------------------------- map symbols -----------------------------

[[merge]]
top_matches = "location"
render_contains = ['(\faLocationDot)', '(\tiLocation)']

[[merge]]
top_matches = "location"
render_contains = ['(\lucideicon{map-pin})', '(\tiLocationOutline)']

[[merge]]
top_matches = "map"
render_contains = [
    '(\faMap[regular])',
    '(\lucideicon{map})',
    '(\tiMap)'
]

# -------------------------- cooking symbols ---------------------------

[[merge]]
top_matches = "oven"
matches = "bottom heat"

[[merge]]
top_matches = "oven"
matches = "top heat"

[[merge]]
top_matches = "oven"
matches = "top and bottom heat"

# ------------------------------- faces --------------------------------

[[merge]]
top_matches = "face"
matches = "smiling"
not_render_contains = ['\twemoji{263a}', '\bcsmbh']

[[merge]]
top_matches = "face"
matches = "frowning"
not_render_contains = '\bcsmmh'

# This rule must appear last in this section.
[[merge]]
top_matches = "face"
not_matches = ["smiling", "frowning"]

# ------------------------------- users --------------------------------

[[merge]]
top_matches = "user"
matches = "slashed"

[[merge]]
top_matches = "user"
render_contains = [
    '(\faUserLarge)',
    '(\faUser)',
    '(\tiUser)',
    '(\lucideicon{user})',
    '(\lucideicon{user-round})'
]

[[merge]]
top_matches = "user"
render_contains = ['(\faUser[regular])', '(\tiUserOutline)']

[[merge]]
top_matches = "user"
matches = "add"
render_contains = [
    '(\tiUserAdd)',
    '(\faUserPlus)',
    '(\lucideicon{user-plus})',
    '(\lucideicon{user-round-plus})'
]

[[merge]]
top_matches = "user"
matches = "delete"
render_contains = [
    '(\tiUserDelete)',
    '(\faUserMinus)',
    '(\lucideicon{user-minus})',
    '(\lucideicon{user-round-minus})'
]

[[merge]]
top_matches = "user"
matches = "gear"
render_contains = [
    '\lucideicon{user-cog}',
    '\lucideicon{user-round-cog}'
]

[[merge]]
top_matches = "user"
matches = "pen"
render_contains = [
    '\lucideicon{user-pen}',
    '\lucideicon{user-round-pen}'
]

[[merge]]
top_matches = "user"
matches = "search"
render_contains = [
    '\lucideicon{user-search}',
    '\lucideicon{user-round-search}'
]

[[merge]]
top_matches = "user"
matches = "X"
render_contains = [
    '\lucideicon{user-x}',
    '\lucideicon{user-round-x}'
]

[[merge]]
top_matches = "user"
matches = "circled"
consider_all_entries = true

# ------------------------------- flags --------------------------------

[[merge]]
top_matches = "flag"
not_matches = ["flag", "multiple, crossed"]

[[merge]]
matches = "maritime signal flag"

# ------------------------------- logic --------------------------------

[[merge]]
consider_all_entries = true
top_matches = "material biconditional"
format_contains = 'hyperindexformat{\see{equivalence'

[[merge]]
consider_all_entries = true
top_matches = "material conditional"
format_contains = 'hyperindexformat{\see{arrow'

[[merge]]
consider_all_entries = true
top_matches = "material conditional"
format_contains = 'hyperindexformat{\see{superset'

[[merge]]
consider_all_entries = true
top_matches = "material equivalence"
format_contains = 'hyperindexformat{\see{arrow'

[[merge]]
consider_all_entries = true
top_matches = "material equivalence"
format_contains = 'hyperindexformat{\see{equivalence'

[[merge]]
consider_all_entries = true
top_matches = "material implication"
format_contains = 'hyperindexformat{\see{arrow'

[[merge]]
consider_all_entries = true
top_matches = "material implication"
format_contains = 'hyperindexformat{\see{superset'

[[merge]]
consider_all_entries = true
top_matches = "material nonimplication"
format_contains = 'hyperindexformat{\see{arrow'

[[merge]]
consider_all_entries = true
top_matches = "material nonimplication"
format_contains = 'hyperindexformat{\see{superset'

[[merge]]
consider_all_entries = true
top_matches = "converse implication"
format_contains = 'hyperindexformat{\see{arrow'

[[merge]]
consider_all_entries = true
top_matches = "converse implication"
format_contains = 'hyperindexformat{\see{subset'

[[merge]]
consider_all_entries = true
top_matches = "converse nonimplication"
format_contains = 'hyperindexformat{\see{arrow'

[[merge]]
consider_all_entries = true
top_matches = "converse nonimplication"
format_contains = 'hyperindexformat{\see{subset'

# -------------------- various mathematical symbols --------------------

[[merge]]
regex = '''
^((not|weak|material|entailment|intuitionistic|implication)\s)*\
(entailment|equivalence|implication)$\
'''
not_render_contains = '(\Equivalence)'

[[merge]]
matches = ["plus or minus", "minus or plus"]

[[merge]]
consider_all_entries = true
matches = "null set"

[[merge]]
consider_all_entries = true
top_matches = "top"
not_render_contains = '\fcSpinning'

[[merge]]
top_matches = "infinity"
render_contains = [
    '(\STIXinfty)',
    '($\ABXinfty$)',
    '($\infty$)',
    '(\MNSinfty)',
    '(\FDSYMinfty)',
    '(\Infin)'
]

[[merge]]
top_matches = "infinity"
render_contains = [
    '(\faInfinity)',
    '(\lucideicon{infinity})',
    '(\tiInfinity)'
]

[[merge]]
top_matches = "infinity"
matches = "incomplete"

[[merge]]
top_matches = "equivalence"
matches = "negated"

[[merge]]
top_matches = "witch"
matches = "math mode"

[[merge]]
top_matches = "square root"
render_contains = ['{\STIXsqrt}', '{\sqrt}']

[[merge]]
top_matches = "square root"
render_contains = "surd"

[[merge]]
top_matches = "proportionality"
matches = "proportionality"

[[merge]]
top_matches = "proportionality"
matches = "reversed"

[[merge]]
render_regex = '\$\\math(left|right)?bat\$'

[[merge]]
top_matches = "pentagon"
not_matches = "half filled"

[[merge]]
top_matches = "hexagon"
not_matches = "half filled"

[[merge]]
top_matches = "union"
not_matches = "square, half"

[[merge]]
top_matches = "intersection"
not_matches = "square, half"

[[merge]]
consider_all_entries = true
top_matches = "cup"
matches = "cup"
not_render_contains = '\BPcup'

[[merge]]
consider_all_entries = true
top_matches = "cap"
matches = "cap"
not_render_contains = '\fcBonnet'

[[merge]]
top_matches = "crossing"
not_matches = "diagonal"

[[merge]]
top_matches = "transform"
render_contains = ['$\laplace$', '\TransformHoriz']

[[merge]]
top_matches = "transform"
render_contains = ['$\Laplace$', '\InversTransformHoriz']

[[merge]]
top_matches = "transform"
render_contains = 'Ztransf'

[[merge]]
top_matches = "transform"
render_contains = 'ztransf'

[[merge]]
top_matches = "transform"
render_contains = 'dfourier'

[[merge]]
top_matches = "transform"
render_contains = 'Dfourier'

[[merge]]
top_matches = "broom"
render_contains = ['\leftbroom', '\rightbroom']

[[merge]]
top_matches = "product"
not_render_contains = '$\varprod$'

[[merge]]
consider_all_entries = true
top_matches = "independence"
format_contains = 'hyperindexformat{\see{turnstile, up}}'

[[merge]]
consider_all_entries = true
top_matches = "independence"
format_contains = 'hyperindexformat{\see{turnstile, double dash, up}}'

[[merge]]
consider_all_entries = true
top_matches = "not"
format_contains = 'hyperindexformat{\see{logical negation}}'

[[merge]]
consider_all_entries = true
top_matches = "not"
format_contains = 'hyperindexformat{\see{slash}}'

[[merge]]
consider_all_entries = true
top_matches = "Vinogradov notation"
format_contains = 'hyperindexformat{\see{equal'

[[merge]]
consider_all_entries = true
top_matches = "Vinogradov notation"
format_contains = 'hyperindexformat{\see{greater'

[[merge]]
consider_all_entries = true
top_matches = "Vinogradov notation"
format_contains = 'hyperindexformat{\see{less'

[[merge]]
consider_all_entries = true
matches = "as math-mode accent"
format_contains = 'hyperindexformat{\see{'

[[merge]]
top_matches = "real"
render_contains = ['$\Re$', '\STIXRe']

[[merge]]
top_matches = "minus"
matches = "decorative"
render_contains = [
    '\usymW{2796}{0.75em}',
    '\twemoji{2796}',
    '\tiMinus',
    '\faMinus',
    '\lucideicon{minus}'
]
not_render_contains = '\tiMinusOutline'

[[merge]]
top_matches = "equal"
matches = "decorative"

[[merge]]
top_matches = "equal"
matches = "decorative, negated"

# ------------------------------ accents -------------------------------

[[merge]]
consider_all_entries = true
matches = [
    "acute",
    "caron",
    "cedilla",
    "circumflex",
    "diaeresis",
    "grave",
    "hacek",
    "krouzek",
    "macron",
    "ogonek",
    "trema"
]

[[merge]]
consider_all_entries = true
top_matches = "breve"
format_contains = '\see{accents'

[[merge]]
consider_all_entries = true
top_matches = "underline"
format_contains = '\see{accents'

[[merge]]
consider_all_entries = true
matches = [
    "ring accent",
    "umlaut"
]
format_contains = '\see{'

[[merge]]
top_matches = "A with ring"
matches = "uppercase"

[[merge]]
consider_all_entries = true
top_matches = "hat"
matches = "accent"

[[merge]]
consider_all_entries = true
top_matches = "biconditional"
format_contains = '\see{arrow, double ended}'

[[merge]]
consider_all_entries = true
top_matches = "biconditional"
format_contains = '\see{equivalence}'

# --------------------------- Greek letters ----------------------------

[[merge]]
compare_lowercase = true
top_matches = [
    "alpha",
    "beta",
    "gamma",
    "delta",
    "epsilon",
    "zeta",
    "eta",
    "theta",
    "iota",
    "kappa",
    "lambda",
    "mu",
    "nu",
    "xi",
    "omicron",
    "pi",
    "rho",
    "sigma",
    "tau",
    "upsilon",
    "phi",
    "chi",
    "psi",
    "omega",
    "digamma",
    "stigma",
    "coppa",
    "koppa",
    "qoppa",
    "sampi"
]

# -------------------------- metrical symbols --------------------------

[[merge]]
top_matches = "obelus"
render_contains = ['(\METREObelus)', '(\METREobelus)']

[[merge]]
top_matches = "obelus"
render_contains = ['(\METREObelusstar)', '(\METREobelusstar)']

[[merge]]
top_matches = "terminus"
render_contains = ['(\METRETerminus)', '(\METREterminus)']

[[merge]]
top_matches = "terminus"
render_contains = ['(\METRETerminusstar)', '(\METREterminusstar)']

# ------------------------- classical elements -------------------------

[[merge]]
top_matches = "air"
render_contains = ['\STARAir', '\SMBTairelement']

[[merge]]
top_matches = "fire"
render_contains = ['\STARFire', '\SMBTfireelement']

[[merge]]
top_matches = "water"
render_contains = ['\STARWater', '\SMBTwaterelement']

[[merge]]
top_matches = "Earth"
render_contains = ['\STAREarth', '\SMBTearthelement']

# ---------------------- astronomy and astrology -----------------------

[[merge]]
top_matches = "Earth"
render_contains = ['\ABXEarth', '\STARTerra']

[[merge]]
top_matches = "Earth"
render_contains = [
    '\ABXvarEarth',
    '\Earth',
    '\STARvarTerra',
    '\SMBTearth',
    '\earth',
    '\usym{2641}'
]

[[merge]]
top_matches = "Uranus"
render_contains = [
    '($\ABXUranus$)',
    '(\SMBTvaruranus)',
    '(\STARvarUranus)',
    '(\uranus)',
    '(\usym{26E2})'
]

[[merge]]
top_matches = "Uranus"
render_contains = [
    '(\SMBTuranus)',
    '(\STARUranus)',
    '(\Uranus)',
    '(\usym{2645})'
]

[[merge]]
top_matches = "Neptune"
render_contains = [
    '($\ABXNeptune$)',
    '(\Neptune)',
    '(\SMBTneptune)',
    '(\STARNeptune)',
    '(\neptune)',
    '(\usym{2646})'
]

[[merge]]
top_matches = "Pluto"
render_contains = ['\Pluto', '\STARPluto']

[[merge]]
top_matches = "Pluto"
render_contains = [
    '$\ABXPluto$',
    '\SMBTpluto',
    '\STARvarPluto',
    '\pluto',
    '\usym{2647}'
]
not_render_contains = '\SMBTplutoform'

[[merge]]
top_matches = "Lilith"
render_contains = ['\SMBTblackmoonlilith', '\usym{26B8}']

# ------------------------------- arrows -------------------------------

[[merge]]
top_matches = "arrowhead"

[[merge]]
top_matches = "arrow"
not_matches = [
    "dingbat",
    "two, dingbat",
    "four, dingbat",
    "fletched",
    "two"
]

[[merge]]
render_contains = ['\faArrowsUpDownLeftRight', '\faUpDownLeftRight']

[[merge]]
top_matches = "external link"
render_contains = [
    '\faArrowUpRightFromSquare',
    '\faUpRightFromSquare',
    '\lucideicon{external-link}'
]

[[merge]]
top_matches = "arrow"
matches = "two, dingbat"
render_contains = [
    '\lucideicon{arrow-down-up}',
    '\lucideicon{arrow-left-right}',
    '\lucideicon{arrow-right-left}',
    '\lucideicon{arrow-up-down}'
]

[[merge]]
top_matches = "arrow"
matches = "dingbat"
render_contains = [
    '(\faArrowUp)',
    '(\faArrowLeft)',
    '(\faArrowDownLong)',
    '(\faArrowDown)',
    '(\faArrowUpLong)',
    '(\faArrowLeftLong)',
    '(\faArrowRight)',
    '(\faArrowRightLong)'
]

# This rule should precede the following one.
[[merge]]
top_matches = "arrow"
matches = "two"
render_regex = 'var(?:left|right)arrows|(up|down|left|right|ne|se|nw|sw)\1arrow'

[[merge]]
top_matches = "arrow"
matches = "two"

[[merge]]
top_matches = "arrow"
render_contains = [
    '\usym{1F504}',
    '\usym{1F503}'
]

[[merge]]
top_matches = "arrow"
render_contains = [
    '(\faUpRightAndDownLeftFromCenter)',
    '(\lucideicon{maximize-2})'
]

[[merge]]
top_matches = "arrow"
matches = "fletched"
render_regex = '\\usym\{27B[4679]\}'

[[merge]]
consider_all_entries = true
top_matches = "rotate"
matches = "rotate"

# ----------------------------- recycling ------------------------------

[[merge]]
top_contains = "recycling"
render_contains = ['\Recycling', '\RECYCrecycle', '\usym{2672}']

[[merge]]
top_contains = "recycling"
render_contains = ['reenpoint', '\PackingWaste']

[[merge]]
top_contains = "recycling"
render_contains = ['\usym{267B}', '\AREVrecycle']

[[merge]]
top_contains = "recycling"
render_contains = ['\twemoji{267b}', '\bcrecyclage']

[[merge]]
top_contains = "recycling"
render_contains = ['\faRecycle', '\lucideicon{recycle}']

[[merge]]
consider_all_entries = true
top_matches = "Green Dot"

[[merge]]
consider_all_entries = true
top_matches = "Grune Punkt"

# ------------------------------ bow ties ------------------------------

[[merge]]
top_contains = "bow tie"
render_contains = [
   '\FDSYMbowtie',
   '\MNSbowtie',
   '\BSKbowtie',
   '\bowtie',
   '\STIXbowtie',
   '\Bowtie'
]

[[merge]]
top_contains = "bow tie"
render_contains = ['\BSKblackbowtie', '\STIXfbowtie']

[[merge]]
top_contains = "bow tie"
render_contains = ['\FDSYMupbowtie', '\MNSvertbowtie']

[[merge]]
top_contains = "bow tie"
render_contains = ['\BSKlblackbowtie', '\STIXlfbowtie']

[[merge]]
top_contains = "bow tie"
render_contains = ['\BSKrblackbowtie', '\STIXrfbowtie']

# ------------------------------ subsets -------------------------------

[[merge]]
top_matches = "subset"
render_regex = '\(\$?\\[A-Z]*sqsubseteq\$?\)|\(\\Sb(map|nch)\)'

[[merge]]
top_matches = "subset"
render_regex = '\(\$?\\[A-Z]*sqsubseteqq\$?\)'

[[merge]]
top_matches = "subset"
render_regex = '\(\$?\\[A-Z]*(var)?sqsubsetneq\$?\)'

[[merge]]
top_matches = "subset"
render_regex = '\(\$?\\[A-Z]*(var)?sqsubsetneqq\$?\)'

[[merge]]
top_matches = "subset"
render_regex = '\(\$?\\[A-Z]*nsqsubseteq\$?\)|\(\\NotSbmap\)'

[[merge]]
top_matches = "subset"
render_regex = '\(\$?\\[A-Z]*nsqsubseteqq\$?\)|\(\\NotSbnch\)'

[[merge]]
top_matches = "subset"
matches = "finite square, negated strict"

[[merge]]
top_matches = "subset"
matches = "finite, strict square"

[[merge]]
top_matches = "subset"
matches = "strict square"

[[merge]]
top_matches = "subset"
matches = "strict square, negated"

[[merge]]
top_matches = "subset"
render_regex = '\(\$?\\[A-Z]*subseteq\$?\)|\(\\Sbset\)'

[[merge]]
top_matches = "subset"
render_regex = '\(\$?\\[A-Z]*subseteqq\$?\)'

[[merge]]
top_matches = "subset"
matches = "finite, negated strict"

[[merge]]
top_matches = "subset"
matches = "finite, strict"

[[merge]]
top_matches = "subset"
matches = "strict"

[[merge]]
top_matches = "subset"
matches = "ordinary, negated"
render_contains = "subseteqq"

# This rule must follow the previous rule.
[[merge]]
top_matches = "subset"
matches = "ordinary, negated"

[[merge]]
top_matches = "subset"
matches = "plus"

[[merge]]
top_matches = "subset"
matches = "plus, strict"
not_render_contains = '\STIXsubsetplus'

[[merge]]
top_matches = "subset"
matches = "strict, negated"

[[merge]]
consider_all_entries = true
top_matches = "subbunch"

[[merge]]
consider_all_entries = true
top_matches = "submap"

# This rule must precede the following one.
[[merge]]
top_matches = "subset"
matches = "proper"
render_contains = 'subsetneqq'

[[merge]]
top_matches = "subset"
matches = "proper"
render_contains = 'subsetneq'

# ----------------------------- supersets ------------------------------

[[merge]]
top_matches = "superset"
render_regex = '\(\$?\\[A-Z]*sqsupseteq\$?\)|\(\\Sb(map|nch)\)'

[[merge]]
top_matches = "superset"
render_regex = '\(\$?\\[A-Z]*sqsupseteqq\$?\)'

[[merge]]
top_matches = "superset"
render_regex = '\(\$?\\[A-Z]*(var)?sqsupsetneq\$?\)'

[[merge]]
top_matches = "superset"
render_regex = '\(\$?\\[A-Z]*(var)?sqsupsetneqq\$?\)'

[[merge]]
top_matches = "superset"
render_regex = '\(\$?\\[A-Z]*nsqsupseteq\$?\)|\(\\NotSbmap\)'

[[merge]]
top_matches = "superset"
render_regex = '\(\$?\\[A-Z]*nsqsupseteqq\$?\)|\(\\NotSbnch\)'

[[merge]]
top_matches = "superset"
matches = "finite square, negated strict"

[[merge]]
top_matches = "superset"
matches = "finite, strict square"

[[merge]]
top_matches = "superset"
matches = "strict square"

[[merge]]
top_matches = "superset"
matches = "strict square, negated"

[[merge]]
top_matches = "superset"
render_regex = '\(\$?\\[A-Z]*supseteq\$?\)'

[[merge]]
top_matches = "superset"
render_regex = '\(\$?\\[A-Z]*supseteqq\$?\)'

[[merge]]
top_matches = "superset"
matches = "finite, strict"

[[merge]]
top_matches = "superset"
matches = "strict"

[[merge]]
top_matches = "superset"
matches = "ordinary, negated"
render_contains = "supseteqq"

# This rule must follow the previous rule.
[[merge]]
top_matches = "superset"
matches = "ordinary, negated"

[[merge]]
top_matches = "superset"
matches = "plus"

[[merge]]
top_matches = "superset"
matches = "plus, strict"
not_render_contains = '\STIXsupsetplus'

# This rule must precede the following one.
[[merge]]
top_matches = "superset"
matches = "proper"
render_contains = 'supsetneqq'

[[merge]]
top_matches = "superset"
matches = "proper"
render_contains = 'supsetneq'

[[merge]]
top_matches = "superset"
matches = "strict, negated"

[[merge]]
top_matches = "superset"
matches = "finite, negated strict"

# ------------------------------- stars --------------------------------

[[merge]]
render_regex = '''
whitestar|\
\(\\(MNSmedstar|\
     FiveStarOpen|\
     MNSlargestar|\
     starlet|\
     fcStarA|\
     usym\{2606\})\)\
'''

[[merge]]
render_contains = [
    '($\star$)',
    '(\MNSthinstar)',
    '(\MNSsmallstar)',
    '(\ABXbigstar)',
    '(\MNSfilledstar)',
    '(\FDSYMmedstar)',
    '(\FDSYMstar)',
    '(\FDSYMmedblackstar)',
    '(\FDSYMsmallblackstar)',
    '(\STIXstar)',
    '(\BSKstar)',
    '($\bigstar$)',
    '(\FiveStar)',
    '($\ABXbigstar$)',
    '(\usym{2605})',
    '(\faStar)',
    '(\FDSYMbigstar)',
    '(\FDSYMlargeblackstar)',
    '(\BSKbigstar)',
    '(\MNSfilledlargestar)',
    '(\STIXbigstar)',
    '(\STIXmedblackstar)',
    '(\starletfill)',
    '(\ARUNEstar)',
    '(\lucideicon{star})'
]

[[merge]]
top_matches = "star"
matches = "jack"

[[merge]]
top_matches = "star"
matches = "pentagram"

[[merge]]
top_matches = "star"
matches = "of David"

[[merge]]
top_matches = "star"
matches = "shadowed"

[[merge]]
top_matches = "star"
matches = "nine pointed"

[[merge]]
top_matches = "star"
matches = "twelve pointed"

[[merge]]
top_matches = "star"
matches = "and crescent"

[[merge]]
top_matches = "star"
render_contains = [
    '(\EightStar)',
    '(\EightStarBold)',
    '(\EightStarTaper)',
    '(\twemoji{2734})',
    '(\usym{2734})',
    '(\usym{2737})',
    '(\usym{2738})'
]

[[merge]]
top_matches = "star"
render_contains = [
    '(\EightStarConvex)',
    '(\usym{2735})'
]

[[merge]]
top_matches = "star"
matches = "of David, dotted"

[[merge]]
top_matches = "star"
render_contains = "hexstar"

# This rule must follow the preceding rule.
[[merge]]
top_matches = "star"
matches = "six pointed"

[[merge]]
top_matches = "star"
matches = "pinwheel"

[[merge]]
top_matches = "star"
render_contains = ['(\FourStar)', '(\usym{2726})']

[[merge]]
top_matches = "star"
render_contains = ['(\FourStarOpen)', '(\usym{2727})']

[[merge]]
top_matches = "star"
matches = "open center"

[[merge]]
top_matches = "star"
matches = "outlined"

[[merge]]
top_matches = "star"
matches = "filled center"

[[merge]]
consider_all_entries = true
top_matches = "star"
matches = "Jewish"

[[merge]]
consider_all_entries = true
matches = "Jewish star"

[[merge]]
top_matches = "star"
matches = "pentagram, circled"

[[merge]]
top_matches = "star"
matches = "pentagram, circled, filled"

[[merge]]
top_matches = "star"
render_contains = ['\faStarHalfStroke', '\starletfillhl']

[[merge]]
top_matches = "star"
matches = "knotted"

# ------------------------------ squares -------------------------------

[[merge]]
top_matches = "square"
not_contains = [
    "with arrow",
    "of squares",
    "of filled squares"
]

[[merge]]
top_matches = "square"
render_contains = ['\boxdotLeft', 'boxdotRight']

[[merge]]
top_matches = "square"
render_contains = ['\boxdotleft', 'boxdotright']

[[merge]]
top_matches = "square"
render_contains = ['\boxLeft', 'boxRight']

[[merge]]
top_matches = "square"
render_contains = ['\boxleft', 'boxright']

# ------------- check boxes, check marks, and cross marks --------------

[[merge]]
top_matches = "check box"

[[merge]]
top_matches = "check mark"

[[merge]]
top_matches = "cross mark"
render_contains = [
    '(\BigCross)',
    '(\XSolid)',
    '(\ifsCross)',
    '(\textifsymbol[ifgeo]{14})'
]

# ------------------------------ crosses -------------------------------

[[merge]]
top_matches = "cross (crucifix)"
matches = "Celtic"

[[merge]]
top_matches = "cross (crucifix)"
matches = "pattee"

[[merge]]
top_matches = "cross (crucifix)"
matches = "outlined"

[[merge]]
top_matches = "cross (crucifix)"
matches = "shadowed"

[[merge]]
top_matches = "cross (crucifix)"
matches = "east Syriac"

[[merge]]
top_matches = "cross (crucifix)"
matches = "west Syriac"

# ------------------------------- hearts -------------------------------

[[merge]]
top_matches = "heart"
matches = "filled"

[[merge]]
top_matches = "heart"
matches = "multiple"

[[merge]]
top_matches = "heart"
matches = "red"

[[merge]]
top_matches = "heart"
render_contains = [
    '(\Heart)',
    '(\faHeart[regular])',
    '(\tiHeartOutline)',
    '(\lucideicon{heart})'
]

# ------------------------- playing card suits -------------------------

[[merge]]
top_matches = "playing card suits"
matches = "club"

[[merge]]
top_matches = "playing card suits"
matches = "club, hollow"

[[merge]]
top_matches = "playing card suits"
matches = "diamond"
not_render_contains = '(\twemoji{2666})'

[[merge]]
top_matches = "playing card suits"
matches = "diamond, filled"

[[merge]]
top_matches = "playing card suits"
matches = "heart"
not_render_contains = '(\twemoji{2665})'

[[merge]]
top_matches = "playing card suits"
matches = "heart, filled"

[[merge]]
top_matches = "playing card suits"
matches = "spade"

[[merge]]
top_matches = "playing card suits"
matches = "spade, hollow"

# ------------------------------- hands --------------------------------

[[merge]]
top_matches = "hand"
matches = "paper sign"

[[merge]]
top_matches = "hand"
matches = "scissors sign"

[[merge]]
top_matches = "hand"
matches = "lizard sign"

[[merge]]
top_matches = "hand"
render_contains = '\twemoji{1f44d'

# ----------------------------- plus signs -----------------------------

[[merge]]
top_matches = "plus"
matches = "bold"

[[merge]]
top_matches = "plus"
matches = "with triangle"

[[merge]]
top_matches = "plus"
render_contains = ["circplus", "ringplus"]

[[merge]]
top_matches = "plus"
render_contains = "pluscirc"

[[merge]]
top_matches = "plus"
render_contains = ["dotplus", "DPlus"]

[[merge]]
top_matches = "plus"
render_contains = "plusdot"

[[merge]]
top_matches = "plus"
matches = "plus"

# ------------------------------ currency ------------------------------

[[merge]]
top_matches = "dollar sign"
render_contains = ['(\textdollar)', '(\ltextdollar)', '(\$)']

[[merge]]
top_matches = "pound"
matches = "math mode"

[[merge]]
top_matches = "pound"
not_render_contains = '\faPoundSign'

[[merge]]
top_matches = "Bitcoin"
render_contains = ['\faBitcoinSign', '\faBtc']

[[merge]]
top_matches = "peso"
render_contains = [
    '\faPesoSign',
    '\lucideicon{philippine-peso}'
]

[[merge]]
top_matches = "rupee"
render_contains = [
    '\faIndianRupeeSign',
    '\lucideicon{indian-rupee}',
    '\rupee'
]

# --------------------------- legal symbols ----------------------------

[[merge]]
top_matches = "legal symbols"
not_matches = "public domain"

[[merge]]
top_matches = "legal symbols"
not_render_contains = '\faCreativeCommonsPd*'

# ---------------------------- equivalence -----------------------------

[[merge]]
top_matches = "equivalence"
matches = "intuitionistic"

[[merge]]
top_matches = "equivalence"
matches = "not intuitionistic"

[[merge]]
top_matches = "equivalence"
matches = "material"

[[merge]]
top_matches = "equivalence"
matches = "not material"

[[merge]]
top_matches = "equivalence"
matches = "weak material"

[[merge]]
top_matches = "equivalence"
matches = "not weak material"

# ------------------------------ equality ------------------------------

[[merge]]
top_matches = "equal"
matches = [
    "asymptotically",
    "asymptotically, negated",
    "dots, falling",
    "dots, falling, negated",
    "dots, negated",
    "dots, rising",
    "dots, rising, negated",
    "equal",
    "extensible",
    "hat",
    "hat, negated",
    "negated",
    "or greater than, negated",
    "or less than, negated",
    "or precedes",
    "or precedes, negated",
    "or succeeds",
    "or succeeds, negated",
    "parallel",
    "star",
    "triangle",
    "triangle, negated",
    "V",
    "wedge"
]

[[merge]]
top_matches = "equal"
matches = "dots"
not_render_contains = "ddotseq"

# colon following a full equal sign
[[merge]]
top_matches = "equal"
matches = "colon, double"
render_contains = ["Eqqcolon", "equalscoloncolon"]

# colon following a half equal sign
[[merge]]
top_matches = "equal"
matches = "colon, double"
render_contains = "Eqcolon"

# bump with a full equal sign below
# This rule must appear before the half equal sign rules.
[[merge]]
top_matches = "equal"
matches = "bump"
render_contains = "bumpeqq"

# negated bump with a full equal sign below
# This rule must appear before the half equal sign rules.
[[merge]]
top_matches = "equal"
matches = "bump, negated"
render_contains = "bumpeqq"

# bump with a half equal sign below
[[merge]]
top_matches = "equal"
matches = "bump"
render_contains = ["bumpeq", "bumpedeq"]

# negated bump with a half equal sign below
[[merge]]
top_matches = "equal"
matches = "bump, negated"
render_contains = ["bumpeq", "bumpedeq"]

# upper and lower bump
[[merge]]
top_matches = "equal"
matches = "bump"
render_contains = ["Bumpeq", "Bumpedeq"]

# lower bump
[[merge]]
top_matches = "equal"
matches = "bump"
render_contains = ["eqbump", "eqbumped"]

# negated lower bump
[[merge]]
top_matches = "equal"
matches = "bump, negated"
render_contains = ["neqbump", "neqbumped"]

# negated upper and lower bump
[[merge]]
top_matches = "equal"
matches = "bump, negated"
render_contains = "nBumpeq"

# full equal followed by a colon
# This rule should precede the following one.
[[merge]]
top_matches = "equal"
matches = "colon"
render_contains = [
    "eqqcolon",
    "equalscolon",
    '\ABXeqcolon',
    '\FDSYMeqcolon',
    '\STIXeqcolon'
]

# half equal followed by a colon
[[merge]]
top_matches = "equal"
matches = "colon"
render_contains = "eqcolon"

# dot below an equal sign
# This rule should precede the following one.
[[merge]]
top_matches = "equal"
matches = "dot"
render_contains = ["eqdot", "botdoteq"]

# dot above an equal sign
[[merge]]
top_matches = "equal"
matches = "dot"
render_contains = "doteq"

# negated dot below an equal sign
[[merge]]
top_matches = "equal"
matches = "dot, negated"
render_contains = "neqdot"

# negated dot above an equal sign
[[merge]]
top_matches = "equal"
matches = "dot, negated"
render_contains = "ndoteq"

# ring above an equal sign
[[merge]]
top_matches = "equal"
matches = "ring"
render_contains = "eqcirc"

# ring within an equal sign
[[merge]]
top_matches = "equal"
matches = "ring"
render_contains = "circeq"

# equal to or greater than, slanted single bar
[[merge]]
top_matches = "equal"
matches = "or greater than"
not_render_contains = [
   '(\STIXeqqslantgtr)',
   '(\STIXeqgtr)',
   '(\STIXeqqgtr)'
]

# equal to or less than, slanted single bar
[[merge]]
top_matches = "equal"
matches = "or less than"
not_render_contains = [
    '(\STIXeqless)',
    '(\STIXeqqslantless)',
    '(\STIXeqqless)'
]

# negated ring above an equal sign
[[merge]]
top_matches = "equal"
matches = "ring, negated"
render_contains = "neqcirc"

# negated ring within an equal sign
[[merge]]
top_matches = "equal"
matches = "ring, negated"
render_contains = "ncirceq"

# "similar to" below a half equal sign
[[merge]]
top_matches = "equal"
matches = "similar"
render_contains = "eqsim"
not_render_contains = "backeqsim"

# negated "similar to" below a half equal sign
[[merge]]
top_matches = "equal"
matches = "similar, negated"
render_contains = "neqsim"

# not equal to
[[merge]]
consider_all_entries = true
top_matches = "not equal"

# ------------------------- smiles and frowns --------------------------

[[merge]]
top_matches = "smiles and frowns"
render_regex = '\\([A-Z]+)?n?(small)?(sq)?smile\b|\\SInCoh\b|\\CMLLsincoh\b'

[[merge]]
top_matches = "smiles and frowns"
render_regex = '\\([A-Z]+)?n?(small)?(sq)?frown\b|\\SCoh\b|\\CMLLscoh\b'

[[merge]]
top_matches = "smiles and frowns"
render_regex = '\\([A-Z]+)?(sq)?smilefrown\b|\\Coh\b|\\CMLLcoh\b'

[[merge]]
top_matches = "smiles and frowns"
render_regex = '\\([A-Z]+)?n?(sq)?frownsmile\b|\\InCoh\b|\\CMLLincoh\b'

[[merge]]
top_matches = "smiles and frowns"
render_regex = '\\([A-Z]+)?(sq)?smilefrowneq\b'

[[merge]]
top_matches = "smiles and frowns"
render_regex = '\\([A-Z]+)?(sq)?frownsmileeq\b'

[[merge]]
top_matches = "smiles and frowns"
render_regex = '\\([A-Z]+)?(sq)?frowneqsmile\b'

[[merge]]
top_matches = "smiles and frowns"
render_regex = '\\([A-Z]+)?(sq)?smileeqfrown\b'

[[merge]]
top_matches = "smiles and frowns"
render_regex = '\\([A-Z]+)n?(sq)?smilefrown\b'

[[merge]]
top_matches = "smiles and frowns"
render_regex = '\\([A-Z]+)?n?(sq)?(double|triple)smile\b'

[[merge]]
top_matches = "smiles and frowns"
render_regex = '\\([A-Z]+)?n?(sq)?(double|triple)frown\b'

[[merge]]
top_matches = "smiles and frowns"
render_regex = '\\([A-Z]+)?n?(sq)?doublesmileeq\b'

[[merge]]
top_matches = "smiles and frowns"
render_regex = '\\([A-Z]+)?n?(sq)?doublefrowneq\b'

[[merge]]
top_matches = "smiles and frowns"
render_regex = '\\([A-Z]+)?n?(sq)?frowneq\b'
not_render_contains = ['\FDSYMfrowneq', '\FDSYMnfrowneq']   # Double equals

[[merge]]
top_matches = "smiles and frowns"
render_regex = '\\([A-Z]+)?n?(sq)?smileeq\b'
not_render_contains = ['\FDSYMsmileeq', '\FDSYMnsmileeq']   # Double equals

[[merge]]
top_matches = "smiles and frowns"
render_regex = '\\([A-Z]+)?n?(sq)?eqfrown\b'

[[merge]]
top_matches = "smiles and frowns"
render_regex = '\\([A-Z]+)?n?(sq)?eqsmile\b'

[[merge]]
top_matches = "smiles and frowns"
render_regex = '\\([A-Z]+)?n?(sq)?frowneqsmile\b'

[[merge]]
top_matches = "smiles and frowns"
render_regex = '\\([A-Z]+)?n?(sq)?smileeqfrown\b'

# ---------------------------- subtraction -----------------------------

[[merge]]
top_matches = "minus"
matches = "minus"

[[merge]]
top_matches = "minus"
matches = "colon"

[[merge]]
top_matches = "minus"
matches = "dot"
render_contains = ["dotminus", "DMinus"]

[[merge]]
top_matches = "minus"
matches = "dot"
render_contains = "minusdot"

[[merge]]
top_matches = "minus"
matches = "dots"
render_contains = "dotsminusdots"

[[merge]]
top_matches = "minus"
matches = "with circle overlay"

# This rule should precede the "backneg"-matching rule.
[[merge]]
top_matches = "minus"
matches = "hooked"
render_contains = ["hookupminus", "invbackneg"]

[[merge]]
top_matches = "minus"
matches = "hooked"
render_contains = ["hookdownminus", "backneg"]

[[merge]]
top_matches = "minus"
matches = "hooked"
render_contains = ["minushookup", "invneg"]

# This rule should follow all of the other hooked-minus rules.
[[merge]]
top_matches = "minus"
matches = "hooked"
render_contains = ["minushookdown", "neg"]

[[merge]]
top_matches = "minus"
matches = "dots"
render_contains = "minusrdots"

[[merge]]
top_matches = "minus"
matches = "dots"
render_contains = "minusfdots"

# ------------------------------ division ------------------------------

[[merge]]
top_matches = "division"
matches = "long"

[[merge]]
top_matches = "division"
matches = "times"

[[merge]]
top_matches = "division"
matches = "decorative"

# Slash
[[merge]]
top_matches = "division"
render_contains = [
    '(\Divide)',
    '(\Divides)',
    '(\FDSYMdivslash)',
    '(\FDSYMsmalldivslash)',
    '(\MNSneswline)',
    '(\MVDivision)'
]

# Line with dots
[[merge]]
top_matches = "division"
render_contains = [
    '($\div$)',
    '(\BSKdiv)',
    '(\Divd)',
    '(\FDSYMdiv)',
    '(\MNSdiv)',
    '(\STIXdiv)',
    '(\textdiv)'
]

[[merge]]
consider_all_entries = true
top_matches = "division times"

[[merge]]
top_matches = "eth"

[[merge]]
top_matches = "consequence relation"
render_contains = 'stile}'

[[merge]]
consider_all_entries = true
top_matches = "divides"
format_contains = 'see{vertical bar, negated}'

[[merge]]
consider_all_entries = true
top_matches = "divides"
format_contains = 'see{vertical bar}'

# -------------------------- assorted letters --------------------------

# ... tailed letters ...

[[merge]]
top_matches = "tailed letters"
matches = "c"

[[merge]]
top_matches = "tailed letters"
matches = "j"

[[merge]]
top_matches = "tailed letters"
matches = "esh"

[[merge]]
top_matches = "tailed letters"
matches = "l"

[[merge]]
top_matches = "tailed letters"
matches = "r"

[[merge]]
top_matches = "tailed letters"
render_contains = ['\textrtailn', '\tailn']

[[merge]]
top_matches = "tailed letters"
render_contains = ['\PHONFCtextltailn', '\textltailn']

[[merge]]
top_matches = "tailed letters"
render_contains = ['\PHONFCtextrtaild', '\taild']

[[merge]]
top_matches = "tailed letters"
render_contains = ['\textrtailt', '\tailt']

[[merge]]
top_matches = "tailed letters"
render_contains = ['\textctt', '\tailt']

[[merge]]
top_matches = "tailed letters"
render_contains = ['\textctz', '\curlyz']

# ... rotated letters ...

[[merge]]
top_matches = "rotated letters"
render_contains = ["textturna", "inva"]

[[merge]]
top_matches = "rotated letters"
render_contains = ["textturnscripta", "invscripta", "rotvara"]

[[merge]]
top_matches = "rotated letters"
not_matches = "a"

# ... other letters ...

[[merge]]
top_matches = "a"

[[merge]]
top_matches = "g"
not_render_contains = '\textg'

[[merge]]
top_matches = "inverted letters"
matches = "r, small caps"

[[merge]]
consider_all_entries = true
top_matches = "rotated letters"
matches = "e"

[[merge]]
top_matches = "o"
matches = "open"

[[merge]]
top_matches = "F"
matches = "inverted"

# ------------------------------ corners -------------------------------

[[merge]]
top_matches = "corner"
render_contains = ["llcorner", "lftbotcorner", "FS"]

[[merge]]
top_matches = "corner"
render_contains = ["lrcorner", "rtbotcorner"]

[[merge]]
top_matches = "corner"
render_contains = [
    "ulcorner",
    "lfttopcorner",
    "textopencorner"
]

[[merge]]
top_matches = "corner"
render_contains = [
    "urcorner",
    "rttopcorner",
    '\corner',
    "textcorner"
]

# ----------------------- approximately equal to -----------------------

[[merge]]
top_matches = "approximately equal to"
render_regex = '\(\$?\\[A-Z]*approxeq\$?\)'

[[merge]]
top_matches = "approximately equal to"
render_regex = '\((\$?\\[A-Z]*(?:thick)?approx\$?|\\lucideicon\{equal-approximately\})\)'

[[merge]]
top_matches = "approximately equal to"
render_regex = '\(\$?\\[A-Z]*napproxeq\$?\)'

[[merge]]
top_matches = "approximately equal to"
render_regex = '\(\$?\\[A-Z]*n(?:thick)?approx\$?\)'

# ----------------------------- rhombuses ------------------------------

[[merge]]
top_matches = "rhombus"
not_matches = [
    "curved, quartered",
    "dotted, with arrow",
    "half filled",
    "nested",
    "patterned",
    "quartered",
    "shadowed",
    "with arrow"
]

[[merge]]
top_matches = "rhombus"
render_contains = ['\DiamonddotLeft', '\DiamonddotRight']

[[merge]]
top_matches = "rhombus"
render_contains = ['\Diamonddotleft', '\Diamonddotright']

[[merge]]
top_matches = "rhombus"
render_contains = ['\DiamondLeft', '\DiamondRight']

[[merge]]
top_matches = "rhombus"
render_contains = ['\Diamondleft', '\Diamondright']

[[merge]]
top_matches = "rhombus"
render_contains = ['\STIXdiamondtopblack', '\rhombusfillha']

[[merge]]
top_matches = "rhombus"
render_contains = [
    '\STIXdiamondbotblack',
    "LowerDiamond",
    '\rhombusfillhb'
]

[[merge]]
top_matches = "rhombus"
render_contains = ['\STIXdiamondleftblack', '\rhombusfillhl']

[[merge]]
top_matches = "rhombus"
render_contains = [
    '\STIXdiamondrightblack',
    "RightDiamond",
    '\rhombusfillhr'
]

[[merge]]
top_matches = "rhombus"
matches = "quartered"
render_contains = ["diamondplus", "rhombuslinevh", "QuarteredDiamond"]

[[merge]]
top_matches = "rhombus"
matches = "quartered"
render_contains = ["diamondtimes", "CrossedDiamond"]

# ------------------------------ circles -------------------------------

[[merge]]
top_matches = "circle"
not_matches = [
    "arrow",
    "enclosing",
    "half filled",
    "half",
    "quarter marked",
    "striped",
    "white on black, half",
    "with arrow"
]

[[merge]]
top_matches = "circle"
matches = "enclosing"
render_contains = '\textcircled'

[[merge]]
compare_lowercase = true
top_matches = "circle"
matches = "half filled"
render_contains = ["left", '\circletfillhl']

[[merge]]
compare_lowercase = true
top_matches = "circle"
matches = "half filled"
render_contains = ["right", '\circletfillhr']

[[merge]]
top_matches = "circle"
matches = "half filled"
render_contains = ["bottom", '\circletfillhb']

[[merge]]
top_matches = "circle"
matches = "half filled"
render_contains = ["top", '\circletfillha']

[[merge]]
top_matches = "circle"
matches = "striped"
render_contains = ['\STIXcirclevertfill', '\usym{1F534}']

[[merge]]
top_matches = "circle"
matches = "with arrow"
render_contains = [
    '($\circleright$)',
    '($\circleleft$)'
]

[[merge]]
top_matches = "circle"
matches = "with arrow"
render_contains = '\lucideicon{circle-arrow-out-'

# ---------------------------- greater than ----------------------------

# ... easy cases ...

[[merge]]
top_matches = "greater than"
matches = [
    "greater than",
    "but not approximately equal to",
    "but not similar to",
    "circle",
    "dotted",
    "dotted, negated",
    "much, negated",
    "negated",
    "or approximately equal to",
    "or approximately equal to, negated",
    "or less than, negated",
    "or less than, overlapping",
    "or similar to, negated",
    "very much, negated"
]

# ... regular ...

[[merge]]
top_matches = "greater than"
matches = "closed"
render_contains = "gtrclosed"

[[merge]]
top_matches = "greater than"
matches = "closed"
render_contains = "cc"

[[merge]]
top_matches = "greater than"
matches = "much"
render_contains = ["ggg", "Gt"]

[[merge]]
top_matches = "greater than"
matches = "much"
not_render_contains = ["ggg", "Gt"]

[[merge]]
top_matches = "greater than"
matches = "but not equal to"
render_contains = "vertneqq"

[[merge]]
top_matches = "greater than"
matches = "but not equal to"
render_contains = "gneqq"

[[merge]]
top_matches = "greater than"
matches = "but not equal to"
render_contains = "gneq"
not_render_contains = "gneqq"

[[merge]]
top_matches = "greater than"
matches = "or equal to"
render_contains = ["geqslant", "SbGre", '($\ABXgeq$)']

[[merge]]
top_matches = "greater than"
matches = "or equal to"
render_contains = "geqq"
not_render_contains = "geqqslant"

[[merge]]
top_matches = "greater than"
matches = "or equal to"
render_contains = ["ge", "Gre"]
not_render_contains = [
    "geqq",
    "geqslant",
    "SbGre",
    "LargerOrEqual",
    "faGreaterThanEqual"
]

[[merge]]
top_matches = "greater than"
matches = "or equal to or less than"
render_contains = "eqqless"
not_render_contains = "slant"

[[merge]]
top_matches = "greater than"
matches = "or equal to or less than"
render_contains = "eqless"
not_render_contains = "slant"

[[merge]]
top_matches = "greater than"
matches = "or equal to or less than"
render_contains = ["eqlessslant", "eqslantless", "gesl"]
not_render_contains = "gesles"

[[merge]]
top_matches = "greater than"
matches = "or equal to, closed"
render_contains = "geqclosed"

[[merge]]
top_matches = "greater than"
matches = "or equal to, closed"
render_contains = "cc"

[[merge]]
top_matches = "greater than"
matches = "or equal to, dotted"
render_contains = "geqdot"

[[merge]]
top_matches = "greater than"
matches = "or equal to, dotted"
render_contains = ["geqslantdot", "gesdot)"]

[[merge]]
top_matches = "greater than"
matches = "or less than"
render_contains = "gtrless"

[[merge]]
top_matches = "greater than"
matches = "or similar to"
not_render_contains = "slant"

[[merge]]
top_matches = "greater than"
matches = "very much"
not_render_contains = "nest"

# ... negated ...

[[merge]]
top_matches = "greater than"
matches = "closed, negated"
render_contains = "gtrclosed"

[[merge]]
top_matches = "greater than"
matches = "closed, negated"
render_contains = "cc"

[[merge]]
top_matches = "greater than"
matches = "or equal to or less than, negated"
render_contains = "eqqless"
not_render_contains = "slant"

[[merge]]
top_matches = "greater than"
matches = "or equal to or less than, negated"
render_contains = "eqless"
not_render_contains = "slant"

[[merge]]
top_matches = "greater than"
matches = "or equal to or less than, negated"
render_contains = ["eqlessslant", "eqslantless", "gesl"]
not_render_contains = "gesles"

[[merge]]
top_matches = "greater than"
matches = "or equal to, closed, negated"
render_contains = "geqclosed"

[[merge]]
top_matches = "greater than"
matches = "or equal to, closed, negated"
render_contains = "cc"

[[merge]]
top_matches = "greater than"
matches = "or equal to, dotted, negated"
render_contains = "ngeqdot"

[[merge]]
top_matches = "greater than"
matches = "or equal to, dotted, negated"
render_contains = ["ngeqslantdot", "ngesdot)"]

[[merge]]
top_matches = "greater than"
matches = "or equal to, negated"
render_contains = ["ngeqslant", '$\ABXngeq$', '(\NotSbGre)']

[[merge]]
top_matches = "greater than"
matches = "or equal to, negated"
render_contains = "ngeqq"

[[merge]]
top_matches = "greater than"
matches = "or equal to, negated"
render_contains = ["nge", '$\ABXnvargeq$', '(\NotGre)']
not_render_contains = ["ngeqq", "ngeqslant"]

# ----------------------------- less than ------------------------------

# ... easy cases ...

[[merge]]
top_matches = "less than"
matches = [
    "less than",
    "but not approximately equal to",
    "but not similar to",
    "circle",
    "dotted",
    "dotted, negated",
    "much, negated",
    "negated",
    "or approximately equal to",
    "or approximately equal to, negated",
    "or greater than",
    "or greater than, negated",
    "or similar to, negated",
    "very much, negated"
]

# ... regular ...

[[merge]]
top_matches = "less than"
matches = "closed"
render_contains = "lessclosed"

[[merge]]
top_matches = "less than"
matches = "closed"
render_contains = "cc"

[[merge]]
top_matches = "less than"
matches = "but not equal to"
render_contains = "vertneqq"

[[merge]]
top_matches = "less than"
matches = "but not equal to"
render_contains = "lneqq"

[[merge]]
top_matches = "less than"
matches = "but not equal to"
render_contains = "lneq"
not_render_contains = "lneqq"

[[merge]]
top_matches = "less than"
matches = "much"
render_contains = ["lll", "Lt"]

[[merge]]
top_matches = "less than"
matches = "much"
not_render_contains = ["lll", "Lt"]

[[merge]]
top_matches = "less than"
matches = "or equal to"
render_contains = ["leqslant", "SbLse", '($\ABXleq$)']

[[merge]]
top_matches = "less than"
matches = "or equal to"
render_contains = "leqq"
not_render_contains = "leqqslant"

[[merge]]
top_matches = "less than"
matches = "or equal to"
render_contains = ["leq", "Lse", 'le)']
not_render_contains = ["leqq", "leqslant", "SbLse"]

[[merge]]
top_matches = "less than"
matches = "or equal to or greater than"
render_contains = "eqqgtr"
not_render_contains = "slant"

[[merge]]
top_matches = "less than"
matches = "or equal to or greater than"
render_contains = "eqgtr"
not_render_contains = "slant"

[[merge]]
top_matches = "less than"
matches = "or equal to or greater than"
render_contains = ["eqgtrslant", "eqslantgtr", "lesg"]
not_render_contains = "lesges"

[[merge]]
top_matches = "less than"
matches = "or equal to, closed"
render_contains = "leqclosed"

[[merge]]
top_matches = "less than"
matches = "or equal to, closed"
render_contains = "cc"

[[merge]]
top_matches = "less than"
matches = "or equal to, dotted"
render_contains = "leqdot"

[[merge]]
top_matches = "less than"
matches = "or equal to, dotted"
render_contains = ["leqslantdot", "lesdot)"]

[[merge]]
top_matches = "less than"
matches = "or similar to"
not_render_contains = "slant"

[[merge]]
top_matches = "less than"
matches = "very much"
not_render_contains = "nest"

# ... negated ...

[[merge]]
top_matches = "less than"
matches = "closed, negated"
render_contains = "lessclosed"

[[merge]]
top_matches = "less than"
matches = "closed, negated"
render_contains = "cc"

[[merge]]
top_matches = "less than"
matches = "or equal to or greater than, negated"
render_contains = ["eqqgtr", "lesg"]
not_render_contains = "slant"

[[merge]]
top_matches = "less than"
matches = "or equal to or greater than, negated"
render_contains = "eqgtr"
not_render_contains = "slant"

[[merge]]
top_matches = "less than"
matches = "or equal to or greater than, negated"
render_contains = ["eqgtrslant", "eqslantgtr"]

[[merge]]
top_matches = "less than"
matches = "or equal to, closed, negated"
render_contains = "leqclosed"

[[merge]]
top_matches = "less than"
matches = "or equal to, closed, negated"
render_contains = "cc"

[[merge]]
top_matches = "less than"
matches = "or equal to, dotted, negated"
render_contains = "nleqdot"

[[merge]]
top_matches = "less than"
matches = "or equal to, dotted, negated"
render_contains = ["nleqslantdot", "nlesdot)"]

[[merge]]
top_matches = "less than"
matches = "or equal to, negated"
render_contains = ["nleqslant", '$\ABXnleq$', '(\NotSbLse)']

[[merge]]
top_matches = "less than"
matches = "or equal to, negated"
render_contains = "nleqq"

[[merge]]
top_matches = "less than"
matches = "or equal to, negated"
render_contains = ["nle", '$\ABXnvarleq$', '(\NotLse)']
not_render_contains = ["nleqq", "nleqslant"]

# ------------------------------- angles -------------------------------

[[merge]]
top_matches = "angle"
matches = [
    "angle",
    "measured, with arrow",
    "spherical",
    "obtuse",
    "with underbar"
]

[[merge]]
top_matches = "angle"
matches = "right"
render_contains = "measuredrightangle"

[[merge]]
top_matches = "angle"
matches = "right"
render_contains = "rightanglemdot"

[[merge]]
top_matches = "angle"
matches = "right"
render_contains = ["rightanglesqr", "rightanglesquare"]

# The following rule should appear last in this section.
[[merge]]
top_matches = "angle"
matches = "right"
render_contains = "rightangle"

# ------------------------------- music --------------------------------

# Barred, rising eighth notes
[[merge]]
top_matches = "musical notes"
render_contains = [
    '(\STIXtwonotes)',
    '(\twoBeamedQuavers)',
    '(\usym{1F39C})'
]

# Barred, rising eighth notes, thick
[[merge]]
top_matches = "musical notes"
render_contains = ['(\faMusic)', '(\tiNotes)']

# Barred, falling eighth notes
[[merge]]
top_matches = "musical notes"
render_contains = [
    '(\twonotes)',
    '(\usym{1F39D})',
    '(\usym{266B})'
]

[[merge]]
consider_all_entries = true
top_matches = "meter, musical"
format_contains = "see{alla breve}"

[[merge]]
top_matches = "antidiple"
render_contains = ['(\METREAntidiple)', '(\METREantidiple)']

[[merge]]
top_matches = "antidiple"
render_contains = ['(\METREAntidiplestar)', '(\METREantidiplestar)']

[[merge]]
top_matches = "diple"
render_contains = ['(\METREDiple)', '(\METREdiple)']

[[merge]]
top_matches = "diple"
render_contains = ['(\METREDiplestar)', '(\METREdiplestar)']

[[merge]]
top_matches = "sharp"
matches = "double"

# ----------------------------- similarity -----------------------------

[[merge]]
top_matches = "similar"
matches = [
    "similar",
    "dots, rising",
    "dots, vertical",
    "dotted",
    "negated",
    "or equal to, dotted",
    "or not equal to",
    "reversed",
    "reversed, negated",
    "thick"
]

[[merge]]
top_matches = "similar"
matches = "or equal to"
render_contains = "cong"

[[merge]]
top_matches = "similar"
matches = "or equal to"
render_contains = ["simeq", "Sm"]

[[merge]]
top_matches = "similar"
matches = "or equal to, negated"
render_contains = "ncong"

[[merge]]
top_matches = "similar"
matches = "or equal to, negated"
render_contains = ["nsime", '\NotSm']

[[merge]]
top_matches = "similar"
matches = "or equal to, reversed"
render_contains = "backcong"

[[merge]]
top_matches = "similar"
matches = "or equal to, reversed"
render_contains = "backsimeq"

[[merge]]
top_matches = "similar"
matches = "or equal to, reversed, negated"
render_contains = "nbackcong"

[[merge]]
top_matches = "similar"
matches = "or equal to, reversed, negated"
render_contains = "nbacksimeq"

# ------------------------------ precedes ------------------------------

[[merge]]
top_matches = "precedes"
matches = [
    "precedes",
    "negated",
    "or approximately equal to",
    "or approximately equal to, negated",
    "or not approximately equal to",
    "or not similar to",
    "or similar to",
    "or similar to, negated",
    "under relation"
]

[[merge]]
top_matches = "precedes"
matches = "double"
render_contains = ['\BSKllcurly', '\STIXPrec']

[[merge]]
top_matches = "precedes"
matches = "or equal to"
render_contains = 'preceqq'

[[merge]]
top_matches = "precedes"
matches = "or equal to"
render_contains = ['preceq', 'Preq']
not_render_contains = 'preceqq'

[[merge]]
top_matches = "precedes"
matches = "or equal to"
render_contains = 'preccurlyeq'

[[merge]]
top_matches = "precedes"
matches = "or not equal to"
render_contains = "precneqq"

[[merge]]
top_matches = "precedes"
matches = "or not equal to"
render_contains = "precneq"
not_render_contains = "precneqq"

[[merge]]
top_matches = "precedes"
matches = "or equal to, negated"
render_contains = 'npreceqq'

[[merge]]
top_matches = "precedes"
matches = "or equal to, negated"
render_contains = ['npreceq', 'NotPreq']
not_render_contains = 'npreceqq'

[[merge]]
top_matches = "precedes"
matches = "or equal to, negated"
render_contains = 'npreccurlyeq'

# ------------------------------ succeeds ------------------------------

[[merge]]
top_matches = "succeeds"
matches = [
    "succeeds",
    "negated",
    "or approximately equal to",
    "or approximately equal to, negated",
    "or not approximately equal to",
    "or not similar to",
    "or similar to",
    "or similar to, negated",
    "under relation"
]

[[merge]]
top_matches = "succeeds"
matches = "double"
render_contains = ['\BSKggcurly', '\STIXSucc']

[[merge]]
top_matches = "succeeds"
matches = "or equal to"
render_contains = 'succeqq'

[[merge]]
top_matches = "succeeds"
matches = "or equal to"
render_contains = ['succeq', 'Sucq']
not_render_contains = 'succeqq'

[[merge]]
top_matches = "succeeds"
matches = "or equal to"
render_contains = 'succcurlyeq'

[[merge]]
top_matches = "succeeds"
matches = "or not equal to"
render_contains = "succneqq"

[[merge]]
top_matches = "succeeds"
matches = "or not equal to"
render_contains = "succneq"
not_render_contains = "succneqq"

[[merge]]
top_matches = "succeeds"
matches = "or equal to, negated"
render_contains = 'nsucceqq'

[[merge]]
top_matches = "succeeds"
matches = "or equal to, negated"
render_contains = ['nsucceq', 'NotSucq']
not_render_contains = 'nsucceqq'

[[merge]]
top_matches = "succeeds"
matches = "or equal to, negated"
render_contains = 'nsucccurlyeq'

# ------------------------------ harpoons ------------------------------

[[merge]]
top_matches = "harpoon"
matches = [
    "harpoon",
    "barred head",
    "barred tail",
    "barred, parallel",
    "double ended, opposite sides",
    "double ended, opposite sides, extensible",
    "double ended, opposite sides, long",
    "double ended, opposite sides, negated",
    "double ended, same side",
    "double, opposite sides",
    "double, opposite sides, negated",
    "double, same side",
    "extensible",
    "long",
    "negated"
]

[[merge]]
top_matches = "harpoon"
matches = "double, opposite sides, extensible"
render_contains = '\auto'

[[merge]]
top_matches = "harpoon"
matches = "double, opposite sides, extensible"
not_render_contains = '\auto'

# ------------------------------- chess --------------------------------

[[merge]]
consider_all_entries = true
top_matches = "bishop"
matches = "chess"

[[merge]]
consider_all_entries = true
top_matches = "king"
matches = "chess"

[[merge]]
consider_all_entries = true
top_matches = "knight"
matches = "chess"

[[merge]]
consider_all_entries = true
top_matches = "pawn"
matches = "chess"

[[merge]]
consider_all_entries = true
top_matches = "queen"
matches = "chess"

[[merge]]
consider_all_entries = true
top_matches = "rook"
matches = "chess"

[[merge]]
consider_all_entries = true
top_matches = "castle"
matches = "chess"

# ----------------------- user-interface symbols -----------------------

[[merge]]
top_matches = [
    "bold",
    "decrease font size",
    "italics",
    "strikethrough"
]

[[merge]]
top_matches = "heading"
matches = "heading"

[[merge]]
top_matches = "history"

[[merge]]
top_matches = "sort"
render_contains = [
    '\lucideicon{arrow-down-a-z}',
    '\faArrowDownAZ'
]

[[merge]]
top_matches = "sort"
render_contains = [
    '\lucideicon{arrow-down-z-a}',
    '\faArrowDownZA'
]

[[merge]]
top_matches = "sort"
render_contains = [
    '\lucideicon{arrow-up-a-z}',
    '\faArrowUpAZ'
]

[[merge]]
top_matches = "sort"
render_contains = [
    '\lucideicon{arrow-up-z-a}',
    '\faArrowUpZA'
]

[[merge]]
top_matches = "sort"
render_contains = [
    '\lucideicon{arrow-down-wide-narrow}',
    '\faArrowDownWideShort'
]

[[merge]]
top_matches = "sort"
render_contains = [
    '\lucideicon{arrow-down-narrow-wide}',
    '\faArrowDownShortWide'
]

[[merge]]
top_matches = "sort"
render_contains = [
    '\lucideicon{arrow-up-wide-narrow}',
    '\faArrowUpWideShort'
]

[[merge]]
top_matches = "sort"
render_contains = [
    '\lucideicon{arrow-up-narrow-wide}',
    '\faArrowUpShortWide'
]

[[merge]]
top_matches = "grip"
render_contains = [
    '(\lucideicon{grip-horizontal})',
    '(\faGrip)'
]

[[merge]]
top_matches = "grip"
render_contains = [
    '(\lucideicon{grip-vertical})',
    '(\faGripVertical)'
]

[[merge]]
consider_all_entries = true
top_matches = "location"
format_contains = 'hyperindexformat{\see{crosshairs'

[[merge]]
top_matches = "sliders"
render_contains = [
    '(\faSliders)',
    '(\lucideicon{sliders-horizontal})'
]

[[merge]]
top_matches = "shell, operating system"
render_contains = [
    '(\faTerminal)',
    '(\lucideicon{terminal})'
]

[[merge]]
top_matches = "ungroup objects"
render_contains = [
    '(\faObjectUngroup[regular])',
    '(\faObjectUngroup)'
]

# ----------------------------- technology -----------------------------

[[merge]]
top_matches = "mouse"
matches = "computer"

[[merge]]
top_matches = "telephone"
render_contains = [
    '(\Phone)',
    '(\Telefon)',
    '(\Telephone)',
    '(\mfPhoneRetro)',
    '(\phone)'
]

[[merge]]
top_matches = "television"
render_contains = [
    '(\faTv)',
    '(\lucideicon{tv-minimal})'
]

[[merge]]
top_matches = "microscope"
render_contains = [
    '(\mfMicroscope)',
    '(\usym{1F52C})'
]

[[merge]]
top_matches = "RSS"
render_contains = [
    '(\faRss)',
    '(\lucideicon{rss})',
    '(\tiRss)'
]

# -------------------------- brands and logos --------------------------

[[merge]]
top_matches = [
    "Agda",
    "Agents",
    "AL",
    "APL",
    "Bazel",
    "Cabal",
    "Cloud Foundry",
    "Codacy",
    "CODEOWNERS",
    "configuration file",
    "Crystal",
    "Dhall",
    "DocPad",
    "Drone",
    "EAS Metadata",
    "font file",
    "Galen",
    "GitHub Copilot",
    "Hjson",
    "io",
    "Jest",
    "Lark",
    "Lerna",
    "Mailing",
    "markdownlint",
    "Marko",
    "MCP",
    "Mustache",
    "Mypy",
    "Neo4j",
    "Next.js",
    "Nim",
    "Nx",
    "OCaml",
    "openHAB",
    "PowerShell",
    "Prettier",
    "Prisma",
    "QML",
    "Quasar",
    "Raku",
    "Razzle",
    "React",
    "React Router",
    "rehype",
    "remark",
    "retext",
    "RuboCop",
    "Safetensors",
    "shadcn/ui",
    "ShaderLab",
    "Solidity",
    "Spin",
    "Stylelint",
    "Stylus",
    "systemd",
    "SystemVerilog",
    "TestCafe",
    "TM",
    "tmux",
    "to-do list",
    "TOML",
    "Turborepo",
    "Unibeautify",
    "Vash",
    "X.Org"
]

[[merge]]
top_matches = "Angular"
matches = "with Dart"

[[merge]]
top_matches = "Angular"
matches = "with JavaScript"

[[merge]]
top_matches = "Angular"
matches = "with TypeScript"

[[merge]]
top_matches = "NestJS"
matches = "with JavaScript"

[[merge]]
top_matches = "NestJS"
matches = "with TypeScript"

[[merge]]
top_matches = "C"
matches = "programming language"

[[merge]]
top_matches = "Go programming language"
render_contains = [
    "{go-aqua}",
    "{go-black}",
    "{go-fuchsia}",
    "{go-lightblue}",
    "{go-work}",
    "{go-yellow}",
    "{go}"
]

[[merge]]
top_matches = "PL/SQL"
matches = "package"

[[merge]]
top_matches = "Dart"
render_contains = [
    "faDartLang",
    "{dartlang-generated}",
    "{dartlang-ignore}",
    "{dartlang}"
]

[[merge]]
top_matches = "YAML"
render_contains = [
    "{light-yaml-official}",
    "{yaml-official}"
]

[[merge]]
top_matches = "YAML"
render_contains = [
    "{light-yaml}",
    "{yaml}"
]

[[merge]]
top_matches = "Visual Studio"
matches = "Visual Studio"

[[merge]]
top_matches = "Visual Studio Code"
matches = "Visual Studio Code"

[[merge]]
top_matches = "TypeScript"
matches = "TypeScript"

[[merge]]
top_matches = "Rust"
matches = "Rust"

[[merge]]
top_matches = "Rust"
matches = "toolchain"

[[merge]]
top_matches = "MDX"
matches = "MDX"

[[merge]]
top_matches = "MDX"
matches = "components"

[[merge]]
top_matches = "JSON"
render_contains = [
    "{json}",
    "{light-json}"
]

[[merge]]
top_matches = "Flutter"
matches = "Flutter"

[[merge]]
top_matches = "Cypress"
matches = "Cypress"

[[merge]]
top_matches = "Cypress"
matches = "spec"

[[merge]]
top_matches = "folder"
matches = "font"

[[merge]]
top_matches = "Git"
render_contains = [
    '(\faGitAlt)',
    '(\mfGit)'
]

[[merge]]
top_matches = "Gradle"
render_contains = ["{gradle}", "{light-gradle}"]

[[merge]]
top_matches = "Gulp"
render_contains = ['(\faGulp)', '(\mfGulp)']

[[merge]]
top_matches = "PHP"
render_contains = ['(\faPhp)', '(\mfPhp)']

[[merge]]
top_matches = "JavaScript"
matches = "configuration"

[[merge]]
top_matches = "Babel"
render_contains = ["{babel2}", "{light-babel2}"]

[[merge]]
top_matches = "Babel"
render_contains = ["{babel}", "{light-babel}"]

[[merge]]
top_matches = "Eleventy"
render_contains = [
    '\faEleventy',
    '{eleventy}',
    '{light-eleventy}'
]

[[merge]]
top_matches = "Eleventy"
render_contains = [
    '{eleventy2}',
    '{light-eleventy2}'
]

[[merge]]
top_matches = "Facebook"
render_contains = [
    '(\faFacebookF)',
    '(\tiSocialFacebook)'
]

[[merge]]
top_matches = "GNU Emacs"
render_contains = ['(\logoemacs)', '\vscodeicon[filetype]{emacs}']

[[merge]]
top_matches = "Lean"
matches = "Lean"

[[merge]]
top_matches = "Lean"
matches = "configuration"

[[merge]]
top_matches = "M"
matches = "programming language"

[[merge]]
top_matches = "Perl"
render_contains = ['(\mfPerl)', '(\vscodeicon[filetype]{perl})']

[[merge]]
top_matches = "PDF"
matches = "file icon"

[[merge]]
top_matches = "Perl 6"
consider_all_entries = true

[[merge]]
top_matches = "ResearchGate"
render_contains = ['(\aiResearchGateSquare)', '(\faResearchgate)']

[[merge]]
top_matches = "TeX"
matches = "logogram"

[[merge]]
top_matches = "tree"
matches = "directory"

[[merge]]
top_matches = "Vimeo"
render_contains = ['(\faSquareVimeo)', '(\faVimeo)']

[[merge]]
top_matches = "Vimeo"
render_contains = ['(\faVimeoV)', '(\tiSocialVimeo)']

[[merge]]
top_matches = "VSIX"
matches = "VSIX"

[[merge]]
top_matches = "parking"
render_contains = ['(\asapParkingSign)', '(\lucideicon{circle-parking})']

[[merge]]
top_matches = "LinkedIn"
render_contains = [
    '(\faLinkedinIn)',
    '(\tiSocialLinkedin)'
]

[[merge]]
top_matches = "LinkedIn"
render_contains = [
    '(\faLinkedin)',
    '(\faSquareLinkedin)'
]

[[merge]]
top_matches = "Tumblr"
render_contains = [
    '(\faTumblr)',
    '(\tiSocialTumbler)'
]

[[merge]]
top_matches = "Twitter"
render_contains = [
    '(\faTwitter)',
    '(\tiSocialTwitter)'
]

[[merge]]
top_matches = "YouTube"
render_contains = [
    '(\faYoutube)',
    '(\tiSocialYoutube)'
]
