Migrate spelling-0.0.21 changes from main

.github/actions/spell-check/advice.txt

@@ -1,25 +0,0 @@
-<details>
-<summary>
-:pencil2: Contributor please read this
-</summary>
-
-By default the command suggestion will generate a file named based on your commit. That's generally ok as long as you add the file to your commit. Someone can reorganize it later.
-
-:warning: The command is written for posix shells. You can copy the contents of each `perl` command excluding the outer `'` marks and dropping any `'"`/`"'` quotation mark pairs into a file and then run `perl file.pl` from the root of the repository to run the code. Alternatively, you can manually insert the items...
-
-If the listed items are:
-* ... **misspelled**, then please *correct* them instead of using the command.
-* ... *names*, please add them to `.github/actions/spell-check/dictionary/names.txt`.
-* ... APIs, you can add them to a file in `.github/actions/spell-check/dictionary/`.
-* ... just things you're using, please add them to an appropriate file in `.github/actions/spell-check/expect/`.
-* ... tokens you only need in one place and shouldn't *generally be used*, you can add an item in an appropriate file in `.github/actions/spell-check/patterns/`.
-
-See the `README.md` in each directory for more information.
-
-:microscope: You can test your commits **without** *appending* to a PR by creating a new branch with that extra change and pushing it to your fork. The [:check-spelling](https://github.com/marketplace/actions/check-spelling) action will run in response to your **push** -- it doesn't require an open pull request. By using such a branch, you can limit the number of typos your peers see you make. :wink:
-
-</details>
-
-#### :warning: Reviewers
-At present, the action that triggered this message will not show its :x: in this PR unless the branch is within this repository.
-Thus, you **should** make sure that this comment has been addressed before encouraging the merge bot to merge this PR.

.github/actions/spell-check/dictionary/apis.txt

@@ -1,44 +0,0 @@
-ACCEPTFILES
-ACCESSDENIED
-alignof
-bitfield
-bitfields
-CLASSNOTAVAILABLE
-EXPCMDFLAGS
-EXPCMDSTATE
-fullkbd
-futex
-href
-IAsync
-IBind
-IBox
-IClass
-IComparable
-ICustom
-IDialog
-IDirect
-IExplorer
-IMap
-IObject
-IStorage
-LCID
-LSHIFT
-NCHITTEST
-NCLBUTTONDBLCLK
-NCRBUTTONDBLCLK
-NOAGGREGATION
-NOREDIRECTIONBITMAP
-oaidl
-ocidl
-PAGESCROLL
-RETURNCMD
-rfind
-roundf
-RSHIFT
-rx
-SIZENS
-spsc
-STDCPP
-syscall
-tmp
-tx

.github/actions/spell-check/dictionary/math.txt

@@ -1,3 +0,0 @@
-powf
-sqrtf
-isnan

.github/actions/spell-check/dictionary/microsoft.txt

@@ -1,18 +0,0 @@
-ACLs
-altform
-backplating
-DACL
-DACLs
-LKG
-mfcribbon
-microsoft
-microsoftonline
-osgvsowi
-powerrename
-powershell
-pscustomobject
-SACLs
-tdbuildteamid
-vcruntime
-visualstudio
-wslpath

.github/actions/spell-check/excludes.txt

@@ -1,63 +0,0 @@
-(?:^|/)dirs$
-(?:^|/)go\.mod$
-(?:^|/)go\.sum$
-(?:^|/)package-lock\.json$
-(?:^|/)sources(?:|\.dep)$
-SUMS$
-\.ai$
-\.bmp$
-\.cer$
-\.class$
-\.crl$
-\.crt$
-\.csr$
-\.dll$
-\.DS_Store$
-\.eot$
-\.eps$
-\.exe$
-\.gif$
-\.graffle$
-\.gz$
-\.icns$
-\.ico$
-\.jar$
-\.jpeg$
-\.jpg$
-\.key$
-\.lib$
-\.lock$
-\.map$
-\.min\..
-\.mp3$
-\.mp4$
-\.otf$
-\.pbxproj$
-\.pdf$
-\.pem$
-\.png$
-\.psd$
-\.runsettings$
-\.sig$
-\.so$
-\.svg$
-\.svgz$
-\.tar$
-\.tgz$
-\.ttf$
-\.woff
-\.xcf$
-\.xls
-\.xpm$
-\.yml$
-\.zip$
-^consolegit2gitfilters\.json$
-^dep/
-^oss/
-^doc/reference/UTF8-torture-test\.txt$
-^src/interactivity/onecore/BgfxEngine\.
-^src/renderer/wddmcon/WddmConRenderer\.
-^src/terminal/parser/ft_fuzzer/VTCommandFuzzer\.cpp$
-^src/tools/U8U16Test/(?:fr|ru|zh)\.txt$
-^\.github/actions/spell-check/
-^\.gitignore$

.github/actions/spell-check/expect/af1ff90dc512c83c902762b02f284c1c61603b4a.txt

@@ -1,10 +0,0 @@
-abcd
-dst
-EFG
-EFGh
-EMPTYBOX
-GFEh
-nrcs
-Remoting
-Scs
-Shobjidl

.github/actions/spell-check/expect/web.txt

@@ -1,15 +0,0 @@
-http
-td
-www
-ecma
-rapidtables
-WCAG
-freedesktop
-ycombinator
-robertelder
-kovidgoyal
-leonerd
-fixterms
-uk
-winui
-appshellintegration

.github/actions/spell-check/patterns/patterns.txt

@@ -1,21 +0,0 @@
-https://(?:(?:[-a-zA-Z0-9?&=]*\.|)microsoft\.com)/[-a-zA-Z0-9?&=_#\/.]*
-https://aka\.ms/[-a-zA-Z0-9?&=\/_]*
-https://www\.itscj\.ipsj\.or\.jp/iso-ir/[-0-9]+\.pdf
-https://www\.vt100\.net/docs/[-a-zA-Z0-9#_\/.]*
-https://www.w3.org/[-a-zA-Z0-9?&=\/_#]*
-https://(?:(?:www\.|)youtube\.com|youtu.be)/[-a-zA-Z0-9?&=]*
-https://[a-z-]+\.githubusercontent\.com/[-a-zA-Z0-9?&=_\/.]*
-[Pp]ublicKeyToken="?[0-9a-fA-F]{16}"?
-(?:[{"]|UniqueIdentifier>)[0-9a-fA-F]{8}-(?:[0-9a-fA-F]{4}-){3}[0-9a-fA-F]{12}(?:[}"]|</UniqueIdentifier)
-(?:0[Xx]|\\x|U\+|#)[a-f0-9A-FGgRr]{2,}[Uu]?[Ll]{0,2}\b
-microsoft/cascadia-code\@[0-9a-fA-F]{40}
-\d+x\d+Logo
-Scro\&ll
-# selectionInput.cpp
- :\\windows\\syste\b
-TestUtils::VerifyExpectedString\(tb, L"[^"]+"
-(?:hostSm|mach)\.ProcessString\(L"[^"]+"
-\b([A-Za-z])\1{3,}\b
-Base64::s_(?:En|De)code\(L"[^"]+"
-VERIFY_ARE_EQUAL\(L"[^"]+"
-L"ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789\+/"

.github/actions/spelling/README.md

@@ -0,0 +1,15 @@
+# check-spelling/check-spelling configuration
+
+File | Purpose | Format | Info
+-|-|-|-
+[allow/*.txt](allow/) | Add words to the dictionary | one word per line (only letters and `'`s allowed) | [allow](https://github.com/check-spelling/check-spelling/wiki/Configuration#allow)
+[reject.txt](reject.txt) | Remove words from the dictionary (after allow) | grep pattern matching whole dictionary words | [reject](https://github.com/check-spelling/check-spelling/wiki/Configuration-Examples%3A-reject)
+[excludes.txt](excludes.txt) | Files to ignore entirely | perl regular expression | [excludes](https://github.com/check-spelling/check-spelling/wiki/Configuration-Examples%3A-excludes)
+[patterns/*.txt](patterns/) | Patterns to ignore from checked lines | perl regular expression (order matters, first match wins) | [patterns](https://github.com/check-spelling/check-spelling/wiki/Configuration-Examples%3A-patterns)
+[candidate.patterns](candidate.patterns) | Patterns that might be worth adding to [patterns.txt](patterns.txt) | perl regular expression with optional comment block introductions (all matches will be suggested) | [candidates](https://github.com/check-spelling/check-spelling/wiki/Feature:-Suggest-patterns)
+[line_forbidden.patterns](line_forbidden.patterns) | Patterns to flag in checked lines | perl regular expression (order matters, first match wins) | [patterns](https://github.com/check-spelling/check-spelling/wiki/Configuration-Examples%3A-patterns)
+[expect/*.txt](expect.txt) | Expected words that aren't in the dictionary | one word per line (sorted, alphabetically) | [expect](https://github.com/check-spelling/check-spelling/wiki/Configuration#expect)
+[advice.md](advice.md) | Supplement for GitHub comment when unrecognized words are found | GitHub Markdown | [advice](https://github.com/check-spelling/check-spelling/wiki/Configuration-Examples%3A-advice)
+
+Note: you can replace any of these files with a directory by the same name (minus the suffix)
+and then include multiple files inside that directory (with that suffix) to merge multiple files together.

.github/actions/spelling/advice.md

@@ -0,0 +1,48 @@
+<!-- See https://github.com/check-spelling/check-spelling/wiki/Configuration-Examples%3A-advice --> <!-- markdownlint-disable MD033 MD041 -->
+<details>
+<summary>
+:pencil2: Contributor please read this
+</summary>
+
+By default the command suggestion will generate a file named based on your commit. That's generally ok as long as you add the file to your commit. Someone can reorganize it later.
+
+:warning: The command is written for posix shells. If it doesn't work for you, you can manually _add_ (one word per line) / _remove_ items to `expect.txt` and the `excludes.txt` files.
+
+If the listed items are:
+
+* ... **misspelled**, then please *correct* them instead of using the command.
+* ... *names*, please add them to `.github/actions/spelling/allow/names.txt`.
+* ... APIs, you can add them to a file in `.github/actions/spelling/allow/`.
+* ... just things you're using, please add them to an appropriate file in `.github/actions/spelling/expect/`.
+* ... tokens you only need in one place and shouldn't *generally be used*, you can add an item in an appropriate file in `.github/actions/spelling/patterns/`.
+
+See the `README.md` in each directory for more information.
+
+:microscope: You can test your commits **without** *appending* to a PR by creating a new branch with that extra change and pushing it to your fork. The [check-spelling](https://github.com/marketplace/actions/check-spelling) action will run in response to your **push** -- it doesn't require an open pull request. By using such a branch, you can limit the number of typos your peers see you make. :wink:
+
+
+<details><summary>If the flagged items are :exploding_head: false positives</summary>
+
+If items relate to a ...
+* binary file (or some other file you wouldn't want to check at all).
+
+  Please add a file path to the `excludes.txt` file matching the containing file.
+
+  File paths are Perl 5 Regular Expressions - you can [test](
+https://www.regexplanet.com/advanced/perl/) yours before committing to verify it will match your files.
+
+  `^` refers to the file's path from the root of the repository, so `^README\.md$` would exclude [README.md](
+../tree/HEAD/README.md) (on whichever branch you're using).
+
+* well-formed pattern.
+
+  If you can write a [pattern](https://github.com/check-spelling/check-spelling/wiki/Configuration-Examples:-patterns) that would match it,
+  try adding it to the `patterns.txt` file.
+
+  Patterns are Perl 5 Regular Expressions - you can [test](
+https://www.regexplanet.com/advanced/perl/) yours before committing to verify it will match your lines.
+
+  Note that patterns can't match multiline strings.
+</details>
+
+</details>

.github/actions/spelling/allow/README.md

@@ -1,6 +1,6 @@
-# Dictionaries are lists of words to accept unconditionally
+# Allow files are lists of words to accept unconditionally
 
-While check spelling will complain about a whitelisted word
+While check spelling will complain about an expected word
 which is no longer present, you can include things here even if
 they are not otherwise present in the repository.
 
@@ -8,13 +8,14 @@ E.g., you could include a list of system APIs here, or potential
 contributors (so that if a future commit includes their name,
 it'll be accepted).
 
-### Files
+## Files
 
 | File | Description |
 | ---- | ----------- |
-| [Dictionary](dictionary.txt) | Primary US English dictionary |
+| [Allow](allow.txt) | Supplements to the dictionary |
 | [Chinese](chinese.txt) | Chinese words |
 | [Japanese](japanese.txt) | Japanese words |
 | [Microsoft](microsoft.txt) | Microsoft brand items |
 | [Fonts](fonts.txt) | Font names |
 | [Names](names.txt) | Names of people |
+| [Colors](colors.txt) | Names of color |

.github/actions/spelling/allow/allow.txt

@@ -0,0 +1,108 @@
+admins
+allcolors
+Apc
+apc
+breadcrumb
+breadcrumbs
+bsd
+calt
+ccmp
+changelog
+clickable
+clig
+CMMI
+copyable
+cybersecurity
+dalet
+Dcs
+dcs
+dialytika
+dje
+downside
+downsides
+dze
+dzhe
+EDDB
+EDDC
+Enum'd
+Fitt
+formattings
+FTCS
+ftp
+fvar
+gantt
+gcc
+geeksforgeeks
+ghe
+github
+gje
+godbolt
+hostname
+hostnames
+https
+hyperlink
+hyperlinking
+hyperlinks
+iconify
+img
+inlined
+It'd
+kje
+libfuzzer
+libuv
+liga
+lje
+Llast
+llvm
+Lmid
+locl
+lol
+lorem
+Lorigin
+maxed
+minimalistic
+mkmk
+mnt
+mru
+nje
+noreply
+ogonek
+ok'd
+overlined
+pipeline
+postmodern
+ptys
+qof
+qps
+rclt
+reimplementation
+reserialization
+reserialize
+reserializes
+rlig
+runtimes
+shcha
+slnt
+Sos
+ssh
+timeline
+timelines
+timestamped
+TLDR
+tokenizes
+tonos
+toolset
+tshe
+ubuntu
+uiatextrange
+UIs
+und
+unregister
+versioned
+vsdevcmd
+We'd
+wildcards
+XBox
+YBox
+yeru
+zhe

.github/actions/spelling/allow/apis.txt

@@ -0,0 +1,248 @@
+ACCEPTFILES
+ACCESSDENIED
+acl
+aclapi
+alignas
+alignof
+APPLYTOSUBMENUS
+appxrecipe
+bitfield
+bitfields
+BUILDBRANCH
+BUILDMSG
+BUILDNUMBER
+BYCOMMAND
+BYPOSITION
+charconv
+CLASSNOTAVAILABLE
+CLOSEAPP
+cmdletbinding
+COLORPROPERTY
+colspan
+COMDLG
+commandlinetoargv
+comparand
+cstdint
+CXICON
+CYICON
+Dacl
+dataobject
+dcomp
+DERR
+dlldata
+DNE
+DONTADDTORECENT
+DWMSBT
+DWMWA
+DWMWA
+DWORDLONG
+endfor
+ENDSESSION
+enumset
+environstrings
+EXPCMDFLAGS
+EXPCMDSTATE
+filetime
+FILTERSPEC
+FORCEFILESYSTEM
+FORCEMINIMIZE
+frac
+fullkbd
+futex
+GETDESKWALLPAPER
+GETHIGHCONTRAST
+GETMOUSEHOVERTIME
+Hashtable
+HIGHCONTRASTON
+HIGHCONTRASTW
+hotkeys
+href
+hrgn
+HTCLOSE
+hwinsta
+HWINSTA
+IActivation
+IApp
+IAppearance
+IAsync
+IBind
+IBox
+IClass
+IComparable
+IComparer
+IConnection
+ICustom
+IDialog
+IDirect
+IExplorer
+IFACEMETHOD
+IFile
+IGraphics
+IInheritable
+IMap
+IMonarch
+IObject
+iosfwd
+IPackage
+IPeasant
+ISetup
+isspace
+IStorage
+istream
+IStringable
+ITab
+ITaskbar
+itow
+IUri
+IVirtual
+KEYSELECT
+LCID
+llabs
+llu
+localtime
+lround
+Lsa
+lsass
+LSHIFT
+LTGRAY
+MAINWINDOW
+memchr
+memicmp
+MENUCOMMAND
+MENUDATA
+MENUINFO
+MENUITEMINFOW
+mmeapi
+MOUSELEAVE
+mov
+mptt
+msappx
+MULTIPLEUSE
+NCHITTEST
+NCLBUTTONDBLCLK
+NCMOUSELEAVE
+NCMOUSEMOVE
+NCRBUTTONDBLCLK
+NIF
+NIN
+NOAGGREGATION
+NOASYNC
+NOCHANGEDIR
+NOPROGRESS
+NOREDIRECTIONBITMAP
+NOREPEAT
+NOTIFYBYPOS
+NOTIFYICON
+NOTIFYICONDATA
+ntprivapi
+oaidl
+ocidl
+ODR
+offsetof
+ofstream
+onefuzz
+osver
+OSVERSIONINFOEXW
+otms
+OUTLINETEXTMETRICW
+overridable
+PACL
+PAGESCROLL
+PATINVERT
+PEXPLICIT
+PICKFOLDERS
+pmr
+ptstr
+QUERYENDSESSION
+rcx
+REGCLS
+RETURNCMD
+rfind
+ROOTOWNER
+roundf
+RSHIFT
+SACL
+schandle
+semver
+serializer
+SETVERSION
+SHELLEXECUTEINFOW
+shobjidl
+SHOWHIDE
+SHOWMINIMIZED
+SHOWTIP
+SINGLEUSE
+SIZENS
+smoothstep
+snprintf
+spsc
+sregex
+SRWLOC
+SRWLOCK
+STDCPP
+STDMETHOD
+strchr
+strcpy
+streambuf
+strtoul
+Stubless
+Subheader
+Subpage
+syscall
+SYSTEMBACKDROP
+TABROW
+TASKBARCREATED
+TBPF
+THEMECHANGED
+tlg
+TME
+tmp
+tmpdir
+tolower
+toupper
+TRACKMOUSEEVENT
+TTask
+TVal
+UChar
+UFIELD
+ULARGE
+UOI
+UPDATEINIFILE
+userenv
+USEROBJECTFLAGS
+Viewbox
+virtualalloc
+wcsstr
+wcstoui
+winmain
+winsta
+winstamin
+wmemcmp
+wpc
+WSF
+wsregex
+wwinmain
+xchg
+XDocument
+XElement
+xfacet
+xhash
+XIcon
+xiosbase
+xlocale
+xlocbuf
+xlocinfo
+xlocmes
+xlocmon
+xlocnum
+xloctime
+XMax
+xmemory
+XParse
+xpath
+xstddef
+xstring
+xtree
+xutility
+YIcon
+YMax

.github/actions/spelling/allow/colors.txt

@@ -0,0 +1,117 @@
+alice
+aliceblue
+antiquewhite
+blanchedalmond
+blueviolet
+burlywood
+cadetblue
+cornflowerblue
+cornsilk
+cyan
+darkblue
+darkcyan
+darkgoldenrod
+darkgray
+darkgreen
+darkgrey
+darkkhaki
+darkmagenta
+darkolivegreen
+darkorange
+darkorchid
+darkred
+darksalmon
+darkseagreen
+darkslateblue
+darkslategray
+darkslategrey
+darkturquoise
+darkviolet
+deeppink
+deepskyblue
+dimgray
+dimgrey
+dodgerblue
+firebrick
+floralwhite
+forestgreen
+gainsboro
+ghostwhite
+greenyellow
+hotpink
+indian
+indianred
+lavenderblush
+lawngreen
+lemonchiffon
+lightblue
+lightcoral
+lightcyan
+lightgoldenrod
+lightgoldenrodyellow
+lightgray
+lightgreen
+lightgrey
+lightpink
+lightsalmon
+lightseagreen
+lightskyblue
+lightslateblue
+lightslategray
+lightslategrey
+lightsteelblue
+lightyellow
+limegreen
+mediumaquamarine
+mediumblue
+mediumorchid
+mediumpurple
+mediumseagreen
+mediumslateblue
+mediumspringgreen
+mediumturquoise
+mediumvioletred
+midnightblue
+mintcream
+mistyrose
+navajo
+navajowhite
+navyblue
+oldlace
+olivedrab
+orangered
+palegoldenrod
+palegreen
+paleturquoise
+palevioletred
+papayawhip
+peachpuff
+peru
+powderblue
+rebecca
+rebeccapurple
+rosybrown
+royalblue
+saddlebrown
+sandybrown
+seagreen
+sienna
+skyblue
+slateblue
+slategray
+slategrey
+springgreen
+steelblue
+violetred
+webgray
+webgreen
+webgrey
+webmaroon
+webpurple
+whitesmoke
+xaroon
+xray
+xreen
+xrey
+xurple
+yellowgreen

.github/actions/spelling/allow/fonts.txt

@@ -1,8 +1,10 @@
 Consolas
 emoji
+emojis
 Extralight
 Gabriola
 Iosevka
 MDL
 Monofur
 Segoe
+wght

.github/actions/spelling/allow/math.txt

@@ -0,0 +1,11 @@
+atan
+CPrime
+HBar
+HPrime
+isnan
+LPrime
+LStep
+powf
+RSub
+sqrtf
+ULP

.github/actions/spelling/allow/microsoft.txt

@@ -0,0 +1,85 @@
+ACLs
+ADMINS
+advapi
+altform
+altforms
+appendwttlogging
+appx
+appxbundle
+appxerror
+appxmanifest
+ATL
+backplating
+bitmaps
+BOMs
+CPLs
+cpptools
+cppvsdbg
+CPRs
+cryptbase
+DACL
+DACLs
+defaultlib
+diffs
+disposables
+dotnetfeed
+DTDs
+DWINRT
+enablewttlogging
+Intelli
+IVisual
+libucrt
+libucrtd
+LKG
+LOCKFILE
+Lxss
+mfcribbon
+microsoft
+microsoftonline
+MSAA
+msixbundle
+MSVC
+MSVCP
+muxc
+netcore
+Onefuzz
+osgvsowi
+PFILETIME
+pgc
+pgo
+pgosweep
+powerrename
+powershell
+propkey
+pscustomobject
+QWORD
+regedit
+robocopy
+SACLs
+sdkddkver
+Shobjidl
+Skype
+SRW
+sxs
+Sysinternals
+sysnative
+systemroot
+taskkill
+tasklist
+tdbuildteamid
+ucrt
+ucrtd
+unvirtualized
+VCRT
+vcruntime
+Virtualization
+visualstudio
+vscode
+VSTHRD
+winsdkver
+wlk
+wslpath
+wtl
+wtt
+wttlog
+Xamarin

.github/actions/spelling/allow/names.txt

@@ -1,43 +1,66 @@
 Anup
 austdi
+arkthur
 Ballmer
 bhoj
 Bhojwani
+Bluloco
 carlos
 dhowett
 Diviness
 dsafa
 duhowett
+DXP
+ekg
+eryksun
 ethanschoonover
 Firefox
 Gatta
+glsl
+Gravell
 Grie
 Griese
 Hernan
 Howett
 Illhardt
+iquilezles
+italo
 jantari
 jerrysh
 Kaiyu
 kimwalisch
 KMehrain
+KODELIFE
+Kodelife
 Kourosh
 kowalczyk
 leonmsft
 Lepilleur
+lhecker
+lukesampson
+Macbook
 Manandhar
+masserano
 mbadolato
 Mehrain
+menger
 mgravell
 michaelniksa
+michkap
 migrie
 mikegr
 mikemaccana
+miloush
 miniksa
 niksa
+nvaccess
+nvda
 oising
 oldnewthing
+opengl
 osgwiki
+pabhojwa
+panos
 paulcam
 pauldotknopf
 PGP
@@ -45,11 +68,18 @@ Pham
 Rincewind
 rprichard
 Schoonover
+shadertoy
+Shomnipotence
+simioni
 Somuah
 sonph
 sonpham
 stakx
+talo
+thereses
 Walisch
+WDX
+Wellons
 Wirt
 Wojciech
 zadjii

.github/actions/spelling/candidate.patterns

@@ -0,0 +1,523 @@
+# marker to ignore all code on line
+^.*/\* #no-spell-check-line \*/.*$
+# marker for ignoring a comment to the end of the line
+// #no-spell-check.*$
+
+# patch hunk comments
+^\@\@ -\d+(?:,\d+|) \+\d+(?:,\d+|) \@\@ .*
+# git index header
+index [0-9a-z]{7,40}\.\.[0-9a-z]{7,40}
+
+# cid urls
+(['"])cid:.*?\g{-1}
+
+# data url in parens
+\(data:[^)]*?(?:[A-Z]{3,}|[A-Z][a-z]{2,}|[a-z]{3,})[^)]*\)
+# data url in quotes
+([`'"])data:.*?(?:[A-Z]{3,}|[A-Z][a-z]{2,}|[a-z]{3,}).*\g{-1}
+# data url
+data:[-a-zA-Z=;:/0-9+]*,\S*
+
+# mailto urls
+mailto:[-a-zA-Z=;:/?%&0-9+@.]{3,}
+
+# magnet urls
+magnet:[?=:\w]+
+
+# magnet urls
+"magnet:[^"]+"
+
+# obs:
+"obs:[^"]*"
+
+# The `\b` here means a break, it's the fancy way to handle urls, but it makes things harder to read
+# In this examples content, I'm using a number of different ways to match things to show various approaches
+# asciinema
+\basciinema\.org/a/[0-9a-zA-Z]+
+
+# apple
+\bdeveloper\.apple\.com/[-\w?=/]+
+# Apple music
+\bembed\.music\.apple\.com/fr/playlist/usr-share/[-\w.]+
+
+# appveyor api
+\bci\.appveyor\.com/api/projects/status/[0-9a-z]+
+# appveyor project
+\bci\.appveyor\.com/project/(?:[^/\s"]*/){2}builds?/\d+/job/[0-9a-z]+
+
+# Amazon
+
+# Amazon
+\bamazon\.com/[-\w]+/(?:dp/[0-9A-Z]+|)
+# AWS S3
+\b\w*\.s3[^.]*\.amazonaws\.com/[-\w/&#%_?:=]*
+# AWS execute-api
+\b[0-9a-z]{10}\.execute-api\.[-0-9a-z]+\.amazonaws\.com\b
+# AWS ELB
+\b\w+\.[-0-9a-z]+\.elb\.amazonaws\.com\b
+# AWS SNS
+\bsns\.[-0-9a-z]+.amazonaws\.com/[-\w/&#%_?:=]*
+# AWS VPC
+vpc-\w+
+
+# While you could try to match `http://` and `https://` by using `s?` in `https?://`, sometimes there
+# YouTube url
+\b(?:(?:www\.|)youtube\.com|youtu.be)/(?:channel/|embed/|user/|playlist\?list=|watch\?v=|v/|)[-a-zA-Z0-9?&=_%]*
+# YouTube music
+\bmusic\.youtube\.com/youtubei/v1/browse(?:[?&]\w+=[-a-zA-Z0-9?&=_]*)
+# YouTube tag
+<\s*youtube\s+id=['"][-a-zA-Z0-9?_]*['"]
+# YouTube image
+\bimg\.youtube\.com/vi/[-a-zA-Z0-9?&=_]*
+# Google Accounts
+\baccounts.google.com/[-_/?=.:;+%&0-9a-zA-Z]*
+# Google Analytics
+\bgoogle-analytics\.com/collect.[-0-9a-zA-Z?%=&_.~]*
+# Google APIs
+\bgoogleapis\.(?:com|dev)/[a-z]+/(?:v\d+/|)[a-z]+/[-@:./?=\w+|&]+
+# Google Storage
+\b[-a-zA-Z0-9.]*\bstorage\d*\.googleapis\.com(?:/\S*|)
+# Google Calendar
+\bcalendar\.google\.com/calendar(?:/u/\d+|)/embed\?src=[@./?=\w&%]+
+\w+\@group\.calendar\.google\.com\b
+# Google DataStudio
+\bdatastudio\.google\.com/(?:(?:c/|)u/\d+/|)(?:embed/|)(?:open|reporting|datasources|s)/[-0-9a-zA-Z]+(?:/page/[-0-9a-zA-Z]+|)
+# The leading `/` here is as opposed to the `\b` above
+# ... a short way to match `https://` or `http://` since most urls have one of those prefixes
+# Google Docs
+/docs\.google\.com/[a-z]+/(?:ccc\?key=\w+|(?:u/\d+|d/(?:e/|)[0-9a-zA-Z_-]+/)?(?:edit\?[-\w=#.]*|/\?[\w=&]*|))
+# Google Drive
+\bdrive\.google\.com/(?:file/d/|open)[-0-9a-zA-Z_?=]*
+# Google Groups
+\bgroups\.google\.com/(?:(?:forum/#!|d/)(?:msg|topics?|searchin)|a)/[^/\s"]+/[-a-zA-Z0-9$]+(?:/[-a-zA-Z0-9]+)*
+# Google Maps
+\bmaps\.google\.com/maps\?[\w&;=]*
+# Google themes
+themes\.googleusercontent\.com/static/fonts/[^/\s"]+/v\d+/[^.]+.
+# Google CDN
+\bclients2\.google(?:usercontent|)\.com[-0-9a-zA-Z/.]*
+# Goo.gl
+/goo\.gl/[a-zA-Z0-9]+
+# Google Chrome Store
+\bchrome\.google\.com/webstore/detail/[-\w]*(?:/\w*|)
+# Google Books
+\bgoogle\.(?:\w{2,4})/books(?:/\w+)*\?[-\w\d=&#.]*
+# Google Fonts
+\bfonts\.(?:googleapis|gstatic)\.com/[-/?=:;+&0-9a-zA-Z]*
+# Google Forms
+\bforms\.gle/\w+
+# Google Scholar
+\bscholar\.google\.com/citations\?user=[A-Za-z0-9_]+
+# Google Colab Research Drive
+\bcolab\.research\.google\.com/drive/[-0-9a-zA-Z_?=]*
+
+# GitHub SHAs (api)
+\bapi.github\.com/repos(?:/[^/\s"]+){3}/[0-9a-f]+\b
+# GitHub SHAs (markdown)
+(?:\[`?[0-9a-f]+`?\]\(https:/|)/(?:www\.|)github\.com(?:/[^/\s"]+){2,}(?:/[^/\s")]+)(?:[0-9a-f]+(?:[-0-9a-zA-Z/#.]*|)\b|)
+# GitHub SHAs
+\bgithub\.com(?:/[^/\s"]+){2}[@#][0-9a-f]+\b
+# GitHub wiki
+\bgithub\.com/(?:[^/]+/){2}wiki/(?:(?:[^/]+/|)_history|[^/]+(?:/_compare|)/[0-9a-f.]{40,})\b
+# githubusercontent
+/[-a-z0-9]+\.githubusercontent\.com/[-a-zA-Z0-9?&=_\/.]*
+# githubassets
+\bgithubassets.com/[0-9a-f]+(?:[-/\w.]+)
+# gist github
+\bgist\.github\.com/[^/\s"]+/[0-9a-f]+
+# git.io
+\bgit\.io/[0-9a-zA-Z]+
+# GitHub JSON
+"node_id": "[-a-zA-Z=;:/0-9+]*"
+# Contributor
+\[[^\]]+\]\(https://github\.com/[^/\s"]+\)
+# GHSA
+GHSA(?:-[0-9a-z]{4}){3}
+
+# GitLab commit
+\bgitlab\.[^/\s"]*/\S+/\S+/commit/[0-9a-f]{7,16}#[0-9a-f]{40}\b
+# GitLab merge requests
+\bgitlab\.[^/\s"]*/\S+/\S+/-/merge_requests/\d+/diffs#[0-9a-f]{40}\b
+# GitLab uploads
+\bgitlab\.[^/\s"]*/uploads/[-a-zA-Z=;:/0-9+]*
+# GitLab commits
+\bgitlab\.[^/\s"]*/(?:[^/\s"]+/){2}commits?/[0-9a-f]+\b
+
+# binanace
+accounts.binance.com/[a-z/]*oauth/authorize\?[-0-9a-zA-Z&%]*
+
+# bitbucket diff
+\bapi\.bitbucket\.org/\d+\.\d+/repositories/(?:[^/\s"]+/){2}diff(?:stat|)(?:/[^/\s"]+){2}:[0-9a-f]+
+# bitbucket repositories commits
+\bapi\.bitbucket\.org/\d+\.\d+/repositories/(?:[^/\s"]+/){2}commits?/[0-9a-f]+
+# bitbucket commits
+\bbitbucket\.org/(?:[^/\s"]+/){2}commits?/[0-9a-f]+
+
+# bit.ly
+\bbit\.ly/\w+
+
+# bitrise
+\bapp\.bitrise\.io/app/[0-9a-f]*/[\w.?=&]*
+
+# bootstrapcdn.com
+\bbootstrapcdn\.com/[-./\w]+
+
+# cdn.cloudflare.com
+\bcdnjs\.cloudflare\.com/[./\w]+
+
+# circleci
+\bcircleci\.com/gh(?:/[^/\s"]+){1,5}.[a-z]+\?[-0-9a-zA-Z=&]+
+
+# gitter
+\bgitter\.im(?:/[^/\s"]+){2}\?at=[0-9a-f]+
+
+# gravatar
+\bgravatar\.com/avatar/[0-9a-f]+
+
+# ibm
+[a-z.]*ibm\.com/[-_#=:%!?~.\\/\d\w]*
+
+# imgur
+\bimgur\.com/[^.]+
+
+# Internet Archive
+\barchive\.org/web/\d+/(?:[-\w.?,'/\\+&%$#_:]*)
+
+# discord
+/discord(?:app\.com|\.gg)/(?:invite/)?[a-zA-Z0-9]{7,}
+
+# Disqus
+\bdisqus\.com/[-\w/%.()!?&=_]*
+
+# medium link
+\blink\.medium\.com/[a-zA-Z0-9]+
+# medium
+\bmedium\.com/\@?[^/\s"]+/[-\w]+
+
+# microsoft
+\b(?:https?://|)(?:(?:download\.visualstudio|docs|msdn2?|research)\.microsoft|blogs\.msdn)\.com/[-_a-zA-Z0-9()=./%]*
+# powerbi
+\bapp\.powerbi\.com/reportEmbed/[^"' ]*
+# vs devops
+\bvisualstudio.com(?::443|)/[-\w/?=%&.]*
+# microsoft store
+\bmicrosoft\.com/store/apps/\w+
+
+# mvnrepository.com
+\bmvnrepository\.com/[-0-9a-z./]+
+
+# now.sh
+/[0-9a-z-.]+\.now\.sh\b
+
+# oracle
+\bdocs\.oracle\.com/[-0-9a-zA-Z./_?#&=]*
+
+# chromatic.com
+/\S+.chromatic.com\S*[")]
+
+# codacy
+\bapi\.codacy\.com/project/badge/Grade/[0-9a-f]+
+
+# compai
+\bcompai\.pub/v1/png/[0-9a-f]+
+
+# mailgun api
+\.api\.mailgun\.net/v3/domains/[0-9a-z]+\.mailgun.org/messages/[0-9a-zA-Z=@]*
+# mailgun
+\b[0-9a-z]+.mailgun.org
+
+# /message-id/
+/message-id/[-\w@./%]+
+
+# Reddit
+\breddit\.com/r/[/\w_]*
+
+# requestb.in
+\brequestb\.in/[0-9a-z]+
+
+# sched
+\b[a-z0-9]+\.sched\.com\b
+
+# Slack url
+slack://[a-zA-Z0-9?&=]+
+# Slack
+\bslack\.com/[-0-9a-zA-Z/_~?&=.]*
+# Slack edge
+\bslack-edge\.com/[-a-zA-Z0-9?&=%./]+
+# Slack images
+\bslack-imgs\.com/[-a-zA-Z0-9?&=%.]+
+
+# shields.io
+\bshields\.io/[-\w/%?=&.:+;,]*
+
+# stackexchange -- https://stackexchange.com/feeds/sites
+\b(?:askubuntu|serverfault|stack(?:exchange|overflow)|superuser).com/(?:questions/\w+/[-\w]+|a/)
+
+# Sentry
+[0-9a-f]{32}\@o\d+\.ingest\.sentry\.io\b
+
+# Twitter markdown
+\[\@[^[/\]:]*?\]\(https://twitter.com/[^/\s"')]*(?:/status/\d+(?:\?[-_0-9a-zA-Z&=]*|)|)\)
+# Twitter hashtag
+\btwitter\.com/hashtag/[\w?_=&]*
+# Twitter status
+\btwitter\.com/[^/\s"')]*(?:/status/\d+(?:\?[-_0-9a-zA-Z&=]*|)|)
+# Twitter profile images
+\btwimg\.com/profile_images/[_\w./]*
+# Twitter media
+\btwimg\.com/media/[-_\w./?=]*
+# Twitter link shortened
+\bt\.co/\w+
+
+# facebook
+\bfburl\.com/[0-9a-z_]+
+# facebook CDN
+\bfbcdn\.net/[\w/.,]*
+# facebook watch
+\bfb\.watch/[0-9A-Za-z]+
+
+# dropbox
+\bdropbox\.com/sh?/[^/\s"]+/[-0-9A-Za-z_.%?=&;]+
+
+# ipfs protocol
+ipfs://[0-9a-z]*
+# ipfs url
+/ipfs/[0-9a-z]*
+
+# w3
+\bw3\.org/[-0-9a-zA-Z/#.]+
+
+# loom
+\bloom\.com/embed/[0-9a-f]+
+
+# regex101
+\bregex101\.com/r/[^/\s"]+/\d+
+
+# figma
+\bfigma\.com/file(?:/[0-9a-zA-Z]+/)+
+
+# freecodecamp.org
+\bfreecodecamp\.org/[-\w/.]+
+
+# image.tmdb.org
+\bimage\.tmdb\.org/[/\w.]+
+
+# mermaid
+\bmermaid\.ink/img/[-\w]+|\bmermaid-js\.github\.io/mermaid-live-editor/#/edit/[-\w]+
+
+# Wikipedia
+\ben\.wikipedia\.org/wiki/[-\w%.#]+
+
+# gitweb
+[^"\s]+/gitweb/\S+;h=[0-9a-f]+
+
+# HyperKitty lists
+/archives/list/[^@/]+\@[^/\s"]*/message/[^/\s"]*/
+
+# lists
+/thread\.html/[^"\s]+
+
+# list-management
+\blist-manage\.com/subscribe(?:[?&](?:u|id)=[0-9a-f]+)+
+
+# kubectl.kubernetes.io/last-applied-configuration
+"kubectl.kubernetes.io/last-applied-configuration": ".*"
+
+# pgp
+\bgnupg\.net/pks/lookup[?&=0-9a-zA-Z]*
+
+# Spotify
+\bopen\.spotify\.com/embed/playlist/\w+
+
+# Mastodon
+\bmastodon\.[-a-z.]*/(?:media/|\@)[?&=0-9a-zA-Z_]*
+
+# scastie
+\bscastie\.scala-lang\.org/[^/]+/\w+
+
+# images.unsplash.com
+\bimages\.unsplash\.com/(?:(?:flagged|reserve)/|)[-\w./%?=%&.;]+
+
+# pastebin
+\bpastebin\.com/[\w/]+
+
+# heroku
+\b\w+\.heroku\.com/source/archive/\w+
+
+# quip
+\b\w+\.quip\.com/\w+(?:(?:#|/issues/)\w+)?
+
+# badgen.net
+\bbadgen\.net/badge/[^")\]'\s]+
+
+# statuspage.io
+\w+\.statuspage\.io\b
+
+# media.giphy.com
+\bmedia\.giphy\.com/media/[^/]+/[\w.?&=]+
+
+# tinyurl
+\btinyurl\.com/\w+
+
+# getopts
+\bgetopts\s+(?:"[^"]+"|'[^']+')
+
+# ANSI color codes
+(?:\\(?:u00|x)1b|\x1b)\[\d+(?:;\d+|)m
+
+# URL escaped characters
+\%[0-9A-F][A-F]
+# IPv6
+\b(?:[0-9a-fA-F]{0,4}:){3,7}[0-9a-fA-F]{0,4}\b
+# c99 hex digits (not the full format, just one I've seen)
+0x[0-9a-fA-F](?:\.[0-9a-fA-F]*|)[pP]
+# Punycode
+\bxn--[-0-9a-z]+
+# sha
+sha\d+:[0-9]*[a-f]{3,}[0-9a-f]*
+# sha-... -- uses a fancy capture
+(['"]|&quot;)[0-9a-f]{40,}\g{-1}
+# hex runs
+\b[0-9a-fA-F]{16,}\b
+# hex in url queries
+=[0-9a-fA-F]*?(?:[A-F]{3,}|[a-f]{3,})[0-9a-fA-F]*?&
+# ssh
+(?:ssh-\S+|-nistp256) [-a-zA-Z=;:/0-9+]{12,}
+
+# PGP
+\b(?:[0-9A-F]{4} ){9}[0-9A-F]{4}\b
+# GPG keys
+\b(?:[0-9A-F]{4} ){5}(?: [0-9A-F]{4}){5}\b
+# Well known gpg keys
+.well-known/openpgpkey/[\w./]+
+
+# uuid:
+\b[0-9a-fA-F]{8}-(?:[0-9a-fA-F]{4}-){3}[0-9a-fA-F]{12}\b
+# hex digits including css/html color classes:
+(?:[\\0][xX]|\\u|[uU]\+|#x?|\%23)[0-9_a-fA-FgGrR]*?[a-fA-FgGrR]{2,}[0-9_a-fA-FgGrR]*(?:[uUlL]{0,3}|u\d+)\b
+# integrity
+integrity="sha\d+-[-a-zA-Z=;:/0-9+]{40,}"
+
+# https://www.gnu.org/software/groff/manual/groff.html
+# man troff content
+\\f[BCIPR]
+# '
+\\\(aq
+
+# .desktop mime types
+^MimeTypes?=.*$
+# .desktop localized entries
+^[A-Z][a-z]+\[[a-z]+\]=.*$
+# Localized .desktop content
+Name\[[^\]]+\]=.*
+
+# IServiceProvider
+\bI(?=(?:[A-Z][a-z]{2,})+\b)
+
+# crypt
+"\$2[ayb]\$.{56}"
+
+# scrypt / argon
+\$(?:scrypt|argon\d+[di]*)\$\S+
+
+# Input to GitHub JSON
+content: "[-a-zA-Z=;:/0-9+]*="
+
+# Python stringprefix / binaryprefix
+# Note that there's a high false positive rate, remove the `?=` and search for the regex to see if the matches seem like reasonable strings
+(?<!')\b(?:B|BR|Br|F|FR|Fr|R|RB|RF|Rb|Rf|U|UR|Ur|b|bR|br|f|fR|fr|r|rB|rF|rb|rf|u|uR|ur)'(?:[A-Z]{3,}|[A-Z][a-z]{2,}|[a-z]{3,})
+
+# Regular expressions for (P|p)assword
+\([A-Z]\|[a-z]\)[a-z]+
+
+# JavaScript regular expressions
+# javascript test regex
+/.*/[gim]*\.test\(
+# javascript match regex
+\.match\(/[^/\s"]*/[gim]*\s*
+# javascript match regex
+\.match\(/\\[b].*?/[gim]*\s*\)(?:;|$)
+# javascript regex
+^\s*/\\[b].*/[gim]*\s*(?:\)(?:;|$)|,$)
+# javascript replace regex
+\.replace\(/[^/\s"]*/[gim]*\s*,
+
+# Go regular expressions
+regexp?\.MustCompile\(`[^`]*`\)
+
+# sed regular expressions
+sed 's/(?:[^/]*?[a-zA-Z]{3,}[^/]*?/){2}
+
+# go install
+go install(?:\s+[a-z]+\.[-@\w/.]+)+
+
+# kubernetes pod status lists
+# https://kubernetes.io/docs/concepts/workloads/pods/pod-lifecycle/#pod-phase
+\w+(?:-\w+)+\s+\d+/\d+\s+(?:Running|Pending|Succeeded|Failed|Unknown)\s+
+
+# kubectl - pods in CrashLoopBackOff
+\w+-[0-9a-f]+-\w+\s+\d+/\d+\s+CrashLoopBackOff\s+
+
+# kubernetes object suffix
+-[0-9a-f]{10}-\w{5}\s
+
+# posthog secrets
+posthog\.init\((['"])phc_[^"',]+\g{-1},
+
+# xcode
+
+# xcodeproject scenes
+(?:Controller|ID|id)="\w{3}-\w{2}-\w{3}"
+
+# xcode api botches
+customObjectInstantitationMethod
+
+# font awesome classes
+\.fa-[-a-z0-9]+
+
+# Update Lorem based on your content (requires `ge` and `w` from https://github.com/jsoref/spelling; and `review` from https://github.com/check-spelling/check-spelling/wiki/Looking-for-items-locally )
+# grep '^[^#].*lorem' .github/actions/spelling/patterns.txt|perl -pne 's/.*i..\?://;s/\).*//' |tr '|' "\n"|sort -f |xargs -n1 ge|perl -pne 's/^[^:]*://'|sort -u|w|sed -e 's/ .*//'|w|review -
+# Warning, while `(?i)` is very neat and fancy, if you have some binary files that aren't proper unicode, you might run into:
+## Operation "substitution (s///)" returns its argument for non-Unicode code point 0x1C19AE (the code point will vary).
+## You could manually change `(?i)X...` to use `[Xx]...`
+## or you could add the files to your `excludes` file (a version after 0.0.19 should identify the file path)
+# Lorem
+(?:\w|\s|[,.])*\b(?i)(?:amet|consectetur|cursus|dolor|eros|ipsum|lacus|libero|ligula|lorem|magna|neque|nulla|suscipit|tempus)\b(?:\w|\s|[,.])*
+
+# Non-English
+[a-zA-Z]*[ÀÁÂÃÄÅÆÇÈÉÊËÌÍÎÏÐÑÒÓÔÕÖØÙÚÛÜÝßàáâãäåæçèéêëìíîïðñòóôõöøùúûüýÿĀāŁłŃńŅņŒœŚśŠšŜŝŸŽžź][a-zA-Z]{3}[a-zA-ZÀÁÂÃÄÅÆÇÈÉÊËÌÍÎÏÐÑÒÓÔÕÖØÙÚÛÜÝßàáâãäåæçèéêëìíîïðñòóôõöøùúûüýÿĀāŁłŃńŅņŒœŚśŠšŜŝŸŽžź]*
+
+# French
+# This corpus only had capital letters, but you probably want lowercase ones as well.
+\b[LN]'+[a-z]{2,}\b
+
+# latex
+\\(?:n(?:ew|ormal|osub)|r(?:enew)|t(?:able(?:of|)|he|itle))(?=[a-z]+)
+
+# the negative lookahead here is to allow catching 'templatesz' as a misspelling
+# but to otherwise recognize a Windows path with \templates\foo.template or similar:
+\\(?:necessary|r(?:eport|esolve[dr]?|esult)|t(?:arget|emplates?))(?![a-z])
+# ignore long runs of a single character:
+\b([A-Za-z])\g{-1}{3,}\b
+# Note that the next example is no longer necessary if you are using
+# to match a string starting with a `#`, use a character-class:
+[#]backwards
+# version suffix <word>v#
+(?:(?<=[A-Z]{2})V|(?<=[a-z]{2}|[A-Z]{2})v)\d+(?:\b|(?=[a-zA-Z_]))
+# Compiler flags (Scala)
+(?:^|[\t ,>"'`=(])-J-[DPWXY](?=[A-Z]{2,}|[A-Z][a-z]|[a-z]{2,})
+# Compiler flags
+#(?:^|[\t ,"'`=(])-[DPWXYLlf](?=[A-Z]{2,}|[A-Z][a-z]|[a-z]{2,})
+
+# Compiler flags (linker)
+,-B
+# curl arguments
+\b(?:\\n|)curl(?:\s+-[a-zA-Z]{1,2}\b)*(?:\s+-[a-zA-Z]{3,})(?:\s+-[a-zA-Z]+)*
+# set arguments
+\bset(?:\s+-[abefimouxE]{1,2})*\s+-[abefimouxE]{3,}(?:\s+-[abefimouxE]+)*
+# tar arguments
+\b(?:\\n|)g?tar(?:\.exe|)(?:(?:\s+--[-a-zA-Z]+|\s+-[a-zA-Z]+|\s[ABGJMOPRSUWZacdfh-pr-xz]+\b)(?:=[^ ]*|))+
+# tput arguments -- https://man7.org/linux/man-pages/man5/terminfo.5.html -- technically they can be more than 5 chars long...
+\btput\s+(?:(?:-[SV]|-T\s*\w+)\s+)*\w{3,5}\b
+# macOS temp folders
+/var/folders/\w\w/[+\w]+/(?:T|-Caches-)/

.github/actions/spelling/excludes.txt

@@ -0,0 +1,117 @@
+# See https://github.com/check-spelling/check-spelling/wiki/Configuration-Examples:-excludes
+(?:(?i)\.png$)
+(?:^|/)(?i)COPYRIGHT
+(?:^|/)(?i)LICEN[CS]E
+(?:^|/)3rdparty/
+(?:^|/)dirs$
+(?:^|/)go\.mod$
+(?:^|/)go\.sum$
+(?:^|/)package(?:-lock|)\.json$
+(?:^|/)sources(?:|\.dep)$
+(?:^|/)vendor/
+\.a$
+\.ai$
+\.avi$
+\.bmp$
+\.bz2$
+\.cer$
+\.class$
+\.crl$
+\.crt$
+\.csr$
+\.dll$
+\.docx?$
+\.drawio$
+\.DS_Store$
+\.eot$
+\.eps$
+\.exe$
+\.gif$
+\.gitattributes$
+\.graffle$
+\.gz$
+\.icns$
+\.ico$
+\.jar$
+\.jks$
+\.jpeg$
+\.jpg$
+\.key$
+\.lib$
+\.lock$
+\.map$
+\.min\..
+\.mod$
+\.mp3$
+\.mp4$
+\.o$
+\.ocf$
+\.otf$
+\.pbxproj$
+\.pdf$
+\.pem$
+\.png$
+\.psd$
+\.pyc$
+\.runsettings$
+\.s$
+\.sig$
+\.so$
+\.svg$
+\.svgz$
+\.svgz?$
+\.tar$
+\.tgz$
+\.tiff?$
+\.ttf$
+\.vsdx$
+\.wav$
+\.webm$
+\.webp$
+\.woff
+\.woff2?$
+\.xcf$
+\.xls
+\.xlsx?$
+\.xpm$
+\.yml$
+\.zip$
+^\.github/actions/spelling/
+^\.github/fabricbot.json$
+^\.gitignore$
+^\Q.git-blame-ignore-revs\E$
+^\Q.github/workflows/spelling.yml\E$
+^\Qdoc/reference/windows-terminal-logo.ans\E$
+^\Qsamples/ConPTY/EchoCon/EchoCon/EchoCon.vcxproj.filters\E$
+^\Qsrc/host/exe/Host.EXE.vcxproj.filters\E$
+^\Qsrc/host/ft_host/chafa.txt\E$
+^\Qsrc/tools/closetest/CloseTest.vcxproj.filters\E$
+^\XamlStyler.json$
+^build/config/
+^consolegit2gitfilters\.json$
+^dep/
+^doc/reference/master-sequence-list.csv$
+^doc/reference/UTF8-torture-test\.txt$
+^oss/
+^src/host/ft_uia/run\.bat$
+^src/host/runft\.bat$
+^src/host/runut\.bat$
+^src/interactivity/onecore/BgfxEngine\.
+^src/renderer/atlas/
+^src/renderer/wddmcon/WddmConRenderer\.
+^src/terminal/adapter/ut_adapter/run\.bat$
+^src/terminal/parser/delfuzzpayload\.bat$
+^src/terminal/parser/ft_fuzzer/run\.bat$
+^src/terminal/parser/ft_fuzzer/VTCommandFuzzer\.cpp$
+^src/terminal/parser/ft_fuzzwrapper/run\.bat$
+^src/terminal/parser/ut_parser/Base64Test.cpp$
+^src/terminal/parser/ut_parser/run\.bat$
+^src/tools/integrity/packageuwp/ConsoleUWP\.appxSources$
+^src/tools/lnkd/lnkd\.bat$
+^src/tools/pixels/pixels\.bat$
+^src/tools/texttests/fira\.txt$
+^src/tools/U8U16Test/(?:fr|ru|zh)\.txt$
+^src/types/ut_types/UtilsTests.cpp$
+^tools/ReleaseEngineering/ServicingPipeline.ps1$
+ignore$
+SUMS$

.github/actions/spelling/expect/alphabet.txt

@@ -1,22 +1,31 @@
-abcde
-abcdef
-ABCDEFG
-ABCDEFGH
+AAAa
+AAAAA
+AAAAAAAAAAAAA
+AAAAAABBBBBBCCC
+AAAAABBBBBBCCC
+abcd
+abcd
 ABCDEFGHIJ
 abcdefghijk
+ABCDEFGHIJKLMNO
 abcdefghijklmnop
 ABCDEFGHIJKLMNOPQRST
-abcdefghijklmnopqrstuvwxyz
+ABCG
 ABE
+abf
+BBBBB
+BBBBBBBB
+BBBBBCCC
+BBBBCCCCC
 BBGGRR
-BBBBBBBBBBBBBBDDDD
+EFG
+EFGh
 QQQQQQQQQQABCDEFGHIJ
 QQQQQQQQQQABCDEFGHIJKLMNOPQRSTQQQQQQQQQ
 QQQQQQQQQQABCDEFGHIJKLMNOPQRSTQQQQQQQQQQ
 QQQQQQQQQQABCDEFGHIJPQRSTQQQQQQQQQQ
 qrstuvwxyz
 qwerty
-QWERTYUIOP
 qwertyuiopasdfg
 YYYYYYYDDDDDDDDDDD
 ZAAZZ
@@ -28,3 +37,4 @@ ZYXWVUT
 ZZBBZ
 ZZZBB
 ZZZBZ
+ZZZZZ

.github/actions/spelling/expect/web.txt

@@ -0,0 +1,6 @@
+WCAG
+winui
+appshellintegration
+mdtauk
+gfycat
+Guake

.github/actions/spelling/line_forbidden.patterns

@@ -0,0 +1,62 @@
+# reject `m_data` as there's a certain OS which has evil defines that break things if it's used elsewhere
+# \bm_data\b
+
+# If you have a framework that uses `it()` for testing and `fit()` for debugging a specific test,
+# you might not want to check in code where you were debugging w/ `fit()`, in which case, you might want
+# to use this:
+#\bfit\(
+
+# s.b. GitHub
+\bGithub\b
+
+# s.b. GitLab
+\bGitlab\b
+
+# s.b. JavaScript
+\bJavascript\b
+
+# s.b. Microsoft
+\bMicroSoft\b
+
+# s.b. another
+\ban[- ]other\b
+
+# s.b. greater than
+\bgreater then\b
+
+# s.b. into
+#\sin to\s
+
+# s.b. opt-in
+\sopt in\s
+
+# s.b. less than
+\bless then\b
+
+# s.b. otherwise
+\bother[- ]wise\b
+
+# s.b. nonexistent
+\bnon existing\b
+\b[Nn]o[nt][- ]existent\b
+
+# s.b. preexisting
+[Pp]re[- ]existing
+
+# s.b. preempt
+[Pp]re[- ]empt\b
+
+# s.b. preemptively
+[Pp]re[- ]emptively
+
+# s.b. reentrancy
+[Rr]e[- ]entrancy
+
+# s.b. reentrant
+[Rr]e[- ]entrant
+
+# s.b. workaround(s)
+#\bwork[- ]arounds?\b
+
+# Reject duplicate words
+\s([A-Z]{3,}|[A-Z][a-z]{2,}|[a-z]{3,})\s\g{-1}\s

.github/actions/spelling/patterns/patterns.txt

@@ -0,0 +1,96 @@
+# See https://github.com/check-spelling/check-spelling/wiki/Configuration-Examples:-patterns
+
+https?://\S+
+[Pp]ublicKeyToken="?[0-9a-fA-F]{16}"?
+(?:[{"]|UniqueIdentifier>)[0-9a-fA-F]{8}-(?:[0-9a-fA-F]{4}-){3}[0-9a-fA-F]{12}(?:[}"]|</UniqueIdentifier)
+(?:0[Xx]|\\x|U\+|#)[a-f0-9A-FGgRr]{2,}[Uu]?[Ll]{0,2}\b
+microsoft/cascadia-code\@[0-9a-fA-F]{40}
+\d+x\d+Logo
+Scro\&ll
+# selectionInput.cpp
+ :\\windows\\syste\b
+TestUtils::VerifyExpectedString\(tb, L"[^"]+"
+(?:hostSm|mach)\.ProcessString\(L"[^"]+"
+\b([A-Za-z])\g{-1}{3,}\b
+0x[0-9A-Za-z]+
+Base64::s_(?:En|De)code\(L"[^"]+"
+VERIFY_ARE_EQUAL\(L"[^"]+"
+"ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789\+/"
+std::memory_order_[\w]+
+D2DERR_SHADER_COMPILE_FAILED
+TIL_FEATURE_[0-9A-Z_]+
+vcvars\w*
+ROY\sG\.\sBIV
+!(?:(?i)ESC)!\[
+!(?:(?i)CSI)!(?:\d+(?:;\d+|)m|[ABCDF])
+
+# Python stringprefix / binaryprefix
+\b(?:B|BR|Br|F|FR|Fr|R|RB|RF|Rb|Rf|U|UR|Ur|b|bR|br|f|fR|fr|r|rB|rF|rb|rf|u|uR|ur)'
+
+# Automatically suggested patterns
+# hit-count: 3831 file-count: 582
+# IServiceProvider
+\bI(?=(?:[A-Z][a-z]{2,})+\b)
+
+# hit-count: 71 file-count: 35
+# Compiler flags
+(?:^|[\t ,"'`=(])-[D](?=[A-Z]{2,}|[A-Z][a-z])
+(?:^|[\t ,"'`=(])-[X](?=[A-Z]{2,}|[A-Z][a-z]|[a-z]{2,})
+
+# hit-count: 41 file-count: 28
+# version suffix <word>v#
+(?:(?<=[A-Z]{2})V|(?<=[a-z]{2}|[A-Z]{2})v)\d+(?:\b|(?=[a-zA-Z_]))
+
+# hit-count: 20 file-count: 9
+# hex runs
+\b[0-9a-fA-F]{16,}\b
+
+# hit-count: 10 file-count: 7
+# uuid:
+\b[0-9a-fA-F]{8}-(?:[0-9a-fA-F]{4}-){3}[0-9a-fA-F]{12}\b
+
+# hit-count: 4 file-count: 4
+# mailto urls
+mailto:[-a-zA-Z=;:/?%&0-9+@.]{3,}
+
+# hit-count: 4 file-count: 1
+# ANSI color codes
+(?:\\(?:u00|x)1b|\x1b)\[\d+(?:;\d+|)m
+
+# hit-count: 2 file-count: 1
+# latex
+\\(?:n(?:ew|ormal|osub)|r(?:enew)|t(?:able(?:of|)|he|itle))(?=[a-z]+)
+
+# hit-count: 1 file-count: 1
+# hex digits including css/html color classes:
+(?:[\\0][xX]|\\u|[uU]\+|#x?|\%23)[0-9_a-fA-FgGrR]*?[a-fA-FgGrR]{2,}[0-9_a-fA-FgGrR]*(?:[uUlL]{0,3}|u\d+)\b
+
+# hit-count: 1 file-count: 1
+# Non-English
+[a-zA-Z]*[ÀÁÂÃÄÅÆÇÈÉÊËÌÍÎÏÐÑÒÓÔÕÖØÙÚÛÜÝßàáâãäåæçèéêëìíîïðñòóôõöøùúûüýÿĀāŁłŃńŅņŒœŚśŠšŜŝŸŽžź][a-zA-Z]{3}[a-zA-ZÀÁÂÃÄÅÆÇÈÉÊËÌÍÎÏÐÑÒÓÔÕÖØÙÚÛÜÝßàáâãäåæçèéêëìíîïðñòóôõöøùúûüýÿĀāŁłŃńŅņŒœŚśŠšŜŝŸŽžź]*
+
+# hit-count: 1 file-count: 1
+# French
+# This corpus only had capital letters, but you probably want lowercase ones as well.
+\b[LN]'+[a-z]{2,}\b
+
+# acceptable duplicates
+# ls directory listings
+[-bcdlpsw](?:[-r][-w][-sx]){3}\s+\d+\s+(\S+)\s+\g{-1}\s+\d+\s+
+# C/idl types + English ...
+\s(Guid|long|LONG|that) \g{-1}\s
+
+# javadoc / .net
+(?:[\\@](?:groupname|param)|(?:public|private)(?:\s+static|\s+readonly)*)\s+(\w+)\s+\g{-1}\s
+
+# Commit message -- Signed-off-by and friends
+^\s*(?:(?:Based-on-patch|Co-authored|Helped|Mentored|Reported|Reviewed|Signed-off)-by|Thanks-to): (?:[^<]*<[^>]*>|[^<]*)\s*$
+
+# Autogenerated revert commit message
+^This reverts commit [0-9a-f]{40}\.$
+
+# vtmode
+--vtmode\s+(\w+)\s+\g{-1}\s
+
+# ignore long runs of a single character:
+\b([A-Za-z])\g{-1}{3,}\b

.github/actions/spelling/reject.txt

@@ -0,0 +1,12 @@
+^attache$
+^attacher$
+^attachers$
+benefitting
+occurences?
+^dependan.*
+^oer$
+Sorce
+^[Ss]pae.*
+^untill$
+^untilling$
+^wether.*

.github/workflows/spelling.yml

@@ -1,20 +0,0 @@
-name: Spell checking
-on:
-  push:
-  schedule:
-    # * is a special character in YAML so you have to quote this string
-    - cron: '15 * * * *'
-
-jobs:
-  build:
-    name: Spell checking
-    runs-on: ubuntu-latest
-    steps:
-    - uses: actions/checkout@v2.0.0
-      with:
-        fetch-depth: 5
-    - uses: check-spelling/check-spelling@0.0.16-alpha
-      env:
-        GITHUB_TOKEN: ${{ secrets.GITHUB_TOKEN }}
-        bucket: .github/actions
-        project: spell-check

.github/workflows/spelling2.yml

@@ -0,0 +1,134 @@
+# spelling.yml is blocked per https://github.com/check-spelling/check-spelling/security/advisories/GHSA-g86g-chm8-7r2p
+name: Spell checking
+
+# Comment management is handled through a secondary job, for details see:
+# https://github.com/check-spelling/check-spelling/wiki/Feature%3A-Restricted-Permissions
+#
+# `jobs.comment-push` runs when a push is made to a repository and the `jobs.spelling` job needs to make a comment
+#   (in odd cases, it might actually run just to collapse a commment, but that's fairly rare)
+#   it needs `contents: write` in order to add a comment.
+#
+# `jobs.comment-pr` runs when a pull_request is made to a repository and the `jobs.spelling` job needs to make a comment
+#   or collapse a comment (in the case where it had previously made a comment and now no longer needs to show a comment)
+#   it needs `pull-requests: write` in order to manipulate those comments.
+
+# Updating pull request branches is managed via comment handling.
+# For details, see: https://github.com/check-spelling/check-spelling/wiki/Feature:-Update-expect-list
+#
+# These elements work together to make it happen:
+#
+# `on.issue_comment`
+#   This event listens to comments by users asking to update the metadata.
+#
+# `jobs.update`
+#   This job runs in response to an issue_comment and will push a new commit
+#   to update the spelling metadata.
+#
+# `with.experimental_apply_changes_via_bot`
+#   Tells the action to support and generate messages that enable it
+#   to make a commit to update the spelling metadata.
+#
+# `with.ssh_key`
+#   In order to trigger workflows when the commit is made, you can provide a
+#   secret (typically, a write-enabled github deploy key).
+#
+#   For background, see: https://github.com/check-spelling/check-spelling/wiki/Feature:-Update-with-deploy-key
+
+on:
+  push:
+    branches:
+    - "**"
+    tags-ignore:
+    - "**"
+  pull_request_target:
+    branches:
+    - "**"
+    tags-ignore:
+    - "**"
+    types:
+    - 'opened'
+    - 'reopened'
+    - 'synchronize'
+  issue_comment:
+    types:
+    - 'created'
+
+jobs:
+  spelling:
+    name: Spell checking
+    permissions:
+      contents: read
+      pull-requests: read
+      actions: read
+    outputs:
+      followup: ${{ steps.spelling.outputs.followup }}
+    runs-on: ubuntu-latest
+    if: "contains(github.event_name, 'pull_request') || github.event_name == 'push'"
+    concurrency:
+      group: spelling-${{ github.event.pull_request.number || github.ref }}
+      # note: If you use only_check_changed_files, you do not want cancel-in-progress
+      cancel-in-progress: true
+    steps:
+    - name: check-spelling
+      id: spelling
+      uses: check-spelling/check-spelling@v0.0.21
+      with:
+        suppress_push_for_open_pull_request: 1
+        checkout: true
+        check_file_names: 1
+        spell_check_this: check-spelling/spell-check-this@prerelease
+        post_comment: 0
+        use_magic_file: 1
+        extra_dictionary_limit: 10
+        extra_dictionaries:
+          cspell:software-terms/src/software-terms.txt
+          cspell:python/src/python/python-lib.txt
+          cspell:node/node.txt
+          cspell:cpp/src/stdlib-c.txt
+          cspell:cpp/src/stdlib-cpp.txt
+          cspell:fullstack/fullstack.txt
+          cspell:filetypes/filetypes.txt
+          cspell:html/html.txt
+          cspell:cpp/src/compiler-msvc.txt
+          cspell:python/src/common/extra.txt
+          cspell:powershell/powershell.txt
+          cspell:aws/aws.txt
+          cspell:cpp/src/lang-keywords.txt
+          cspell:npm/npm.txt
+          cspell:dotnet/dotnet.txt
+          cspell:python/src/python/python.txt
+          cspell:css/css.txt
+          cspell:cpp/src/stdlib-cmath.txt
+        check_extra_dictionaries: ''
+
+  comment-push:
+    name: Report (Push)
+    # If your workflow isn't running on push, you can remove this job
+    runs-on: ubuntu-latest
+    needs: spelling
+    permissions:
+      contents: write
+    if: (success() || failure()) && needs.spelling.outputs.followup && github.event_name == 'push'
+    steps:
+    - name: comment
+      uses: check-spelling/check-spelling@v0.0.21
+      with:
+        checkout: true
+        spell_check_this: check-spelling/spell-check-this@prerelease
+        task: ${{ needs.spelling.outputs.followup }}
+
+  comment-pr:
+    name: Report (PR)
+    # If you workflow isn't running on pull_request*, you can remove this job
+    runs-on: ubuntu-latest
+    needs: spelling
+    permissions:
+      pull-requests: write
+    if: (success() || failure()) && needs.spelling.outputs.followup && contains(github.event_name, 'pull_request')
+    steps:
+    - name: comment
+      uses: check-spelling/check-spelling@v0.0.21
+      with:
+        checkout: true
+        spell_check_this: check-spelling/spell-check-this@prerelease
+        task: ${{ needs.spelling.outputs.followup }}

NuGet.Config

@@ -8,7 +8,7 @@
         <!--<add key="Static Package Dependencies" value="dep\packages" />-->
         
         <!-- Use our own NuGet Feed -->
-        <add key="TerminalDependencies" value="https://pkgs.dev.azure.com/ms/terminal/_packaging/TerminalDependencies/nuget/v3/index.json" />
+        <add key="Windows Terminal NuGet Feed" value="https://terminalnuget.blob.core.windows.net/feed/index.json" />
         
         <!-- Internal NuGet feeds that may not be accessible outside Microsoft corporate network -->
         <!--<add key="TAEF - internal" value="https://microsoft.pkgs.visualstudio.com/DefaultCollection/_packaging/Taef/nuget/v3/index.json" />

res/README.md

@@ -17,5 +17,5 @@ Please consult the [license](https://raw.githubusercontent.com/microsoft/cascadi
 
 ### Fonts Included
 
-* Cascadia Code, Cascadia Mono (2007.15)
-   * from microsoft/cascadia-code@2a54363b2c867f7ae811b9a034c0024cef67de96
+* Cascadia Code, Cascadia Mono (2007.01)
+   * from microsoft/cascadia-code@311cc603f30635da704b6a7d13050e245e61667b

src/buffer/out/AttrRow.cpp

@@ -108,7 +108,12 @@ TextAttribute ATTR_ROW::GetAttrByColumn(const size_t column,
 {
     THROW_HR_IF(E_INVALIDARG, column >= _cchRowWidth);
     const auto runPos = FindAttrIndex(column, pApplies);
-    return _list.at(runPos).GetAttributes();
+    return GetAttrByIndex(runPos);
+}
+
+TextAttribute ATTR_ROW::GetAttrByIndex(const size_t index) const
+{
+    return _list.at(index).GetAttributes();
 }
 
 // Routine Description:
@@ -223,7 +228,7 @@ void ATTR_ROW::ReplaceAttrs(const TextAttribute& toBeReplacedAttr, const TextAtt
 // Return Value:
 // - STATUS_NO_MEMORY if there wasn't enough memory to insert the runs
 //   otherwise STATUS_SUCCESS if we were successful.
-[[nodiscard]] HRESULT ATTR_ROW::InsertAttrRuns(const gsl::span<const TextAttributeRun> newAttrs,
+[[nodiscard]] HRESULT ATTR_ROW::InsertAttrRuns(const std::basic_string_view<TextAttributeRun> newAttrs,
                                                const size_t iStart,
                                                const size_t iEnd,
                                                const size_t cBufferWidth)
@@ -250,7 +255,7 @@ void ATTR_ROW::ReplaceAttrs(const TextAttribute& toBeReplacedAttr, const TextAtt
     if (newAttrs.size() == 1)
     {
         // Get the new color attribute we're trying to apply
-        const TextAttribute NewAttr = til::at(newAttrs, 0).GetAttributes();
+        const TextAttribute NewAttr = newAttrs.at(0).GetAttributes();
 
         // If the existing run was only 1 element...
         // ...and the new color is the same as the old, we don't have to do anything and can exit quick.
@@ -372,7 +377,7 @@ void ATTR_ROW::ReplaceAttrs(const TextAttribute& toBeReplacedAttr, const TextAtt
     if (iStart == 0 && iEnd == iLastBufferCol)
     {
         // Just dump what we're given over what we have and call it a day.
-        _list.assign(newAttrs.begin(), newAttrs.end());
+        _list.assign(newAttrs.cbegin(), newAttrs.cend());
 
         return S_OK;
     }

src/buffer/out/AttrRow.hpp

@@ -36,6 +36,8 @@ public:
     TextAttribute GetAttrByColumn(const size_t column,
                                   size_t* const pApplies) const;
 
+    TextAttribute GetAttrByIndex(const size_t index) const;
+
     size_t GetNumberOfRuns() const noexcept;
 
     size_t FindAttrIndex(const size_t index,
@@ -46,7 +48,7 @@ public:
 
     void Resize(const size_t newWidth);
 
-    [[nodiscard]] HRESULT InsertAttrRuns(const gsl::span<const TextAttributeRun> newAttrs,
+    [[nodiscard]] HRESULT InsertAttrRuns(const std::basic_string_view<TextAttributeRun> newAttrs,
                                          const size_t iStart,
                                          const size_t iEnd,
                                          const size_t cBufferWidth);

src/buffer/out/OutputCellIterator.cpp

@@ -112,9 +112,9 @@ OutputCellIterator::OutputCellIterator(const std::wstring_view utf16Text, const
 // - This is an iterator over legacy colors only. The text is not modified.
 // Arguments:
 // - legacyAttrs - One legacy color item per cell
-OutputCellIterator::OutputCellIterator(const gsl::span<const WORD> legacyAttrs) noexcept :
+OutputCellIterator::OutputCellIterator(const std::basic_string_view<WORD> legacyAttrs) noexcept :
     _mode(Mode::LegacyAttr),
-    _currentView(s_GenerateViewLegacyAttr(til::at(legacyAttrs, 0))),
+    _currentView(s_GenerateViewLegacyAttr(legacyAttrs.at(0))),
     _run(legacyAttrs),
     _attr(InvalidTextAttribute),
     _distance(0),
@@ -127,9 +127,9 @@ OutputCellIterator::OutputCellIterator(const gsl::span<const WORD> legacyAttrs)
 // - This is an iterator over legacy cell data. We will use the unicode text and the legacy color attribute.
 // Arguments:
 // - charInfos - Multiple cell with unicode text and legacy color data.
-OutputCellIterator::OutputCellIterator(const gsl::span<const CHAR_INFO> charInfos) noexcept :
+OutputCellIterator::OutputCellIterator(const std::basic_string_view<CHAR_INFO> charInfos) noexcept :
     _mode(Mode::CharInfo),
-    _currentView(s_GenerateView(til::at(charInfos, 0))),
+    _currentView(s_GenerateView(charInfos.at(0))),
     _run(charInfos),
     _attr(InvalidTextAttribute),
     _distance(0),
@@ -142,9 +142,9 @@ OutputCellIterator::OutputCellIterator(const gsl::span<const CHAR_INFO> charInfo
 // - This is an iterator over existing OutputCells with full text and color data.
 // Arguments:
 // - cells - Multiple cells in a run
-OutputCellIterator::OutputCellIterator(const gsl::span<const OutputCell> cells) :
+OutputCellIterator::OutputCellIterator(const std::basic_string_view<OutputCell> cells) :
     _mode(Mode::Cell),
-    _currentView(s_GenerateView(til::at(cells, 0))),
+    _currentView(s_GenerateView(cells.at(0))),
     _run(cells),
     _attr(InvalidTextAttribute),
     _distance(0),
@@ -180,15 +180,15 @@ OutputCellIterator::operator bool() const noexcept
         }
         case Mode::Cell:
         {
-            return _pos < std::get<gsl::span<const OutputCell>>(_run).size();
+            return _pos < std::get<std::basic_string_view<OutputCell>>(_run).length();
         }
         case Mode::CharInfo:
         {
-            return _pos < std::get<gsl::span<const CHAR_INFO>>(_run).size();
+            return _pos < std::get<std::basic_string_view<CHAR_INFO>>(_run).length();
         }
         case Mode::LegacyAttr:
         {
-            return _pos < std::get<gsl::span<const WORD>>(_run).size();
+            return _pos < std::get<std::basic_string_view<WORD>>(_run).length();
         }
         default:
             FAIL_FAST_HR(E_NOTIMPL);
@@ -265,7 +265,7 @@ OutputCellIterator& OutputCellIterator::operator++()
         _pos++;
         if (operator bool())
         {
-            _currentView = s_GenerateView(til::at(std::get<gsl::span<const OutputCell>>(_run), _pos));
+            _currentView = s_GenerateView(std::get<std::basic_string_view<OutputCell>>(_run).at(_pos));
         }
         break;
     }
@@ -275,7 +275,7 @@ OutputCellIterator& OutputCellIterator::operator++()
         _pos++;
         if (operator bool())
         {
-            _currentView = s_GenerateView(til::at(std::get<gsl::span<const CHAR_INFO>>(_run), _pos));
+            _currentView = s_GenerateView(std::get<std::basic_string_view<CHAR_INFO>>(_run).at(_pos));
         }
         break;
     }
@@ -285,7 +285,7 @@ OutputCellIterator& OutputCellIterator::operator++()
         _pos++;
         if (operator bool())
         {
-            _currentView = s_GenerateViewLegacyAttr(til::at(std::get<gsl::span<const WORD>>(_run), _pos));
+            _currentView = s_GenerateViewLegacyAttr(std::get<std::basic_string_view<WORD>>(_run).at(_pos));
         }
         break;
     }

src/buffer/out/OutputCellIterator.hpp

@@ -39,9 +39,9 @@ public:
     OutputCellIterator(const CHAR_INFO& charInfo, const size_t fillLimit = 0) noexcept;
     OutputCellIterator(const std::wstring_view utf16Text);
     OutputCellIterator(const std::wstring_view utf16Text, const TextAttribute attribute);
-    OutputCellIterator(const gsl::span<const WORD> legacyAttributes) noexcept;
-    OutputCellIterator(const gsl::span<const CHAR_INFO> charInfos) noexcept;
-    OutputCellIterator(const gsl::span<const OutputCell> cells);
+    OutputCellIterator(const std::basic_string_view<WORD> legacyAttributes) noexcept;
+    OutputCellIterator(const std::basic_string_view<CHAR_INFO> charInfos) noexcept;
+    OutputCellIterator(const std::basic_string_view<OutputCell> cells);
     ~OutputCellIterator() = default;
 
     OutputCellIterator& operator=(const OutputCellIterator& it) = default;
@@ -86,13 +86,13 @@ private:
     };
     Mode _mode;
 
-    gsl::span<const WORD> _legacyAttrs;
+    std::basic_string_view<WORD> _legacyAttrs;
 
     std::variant<
         std::wstring_view,
-        gsl::span<const WORD>,
-        gsl::span<const CHAR_INFO>,
-        gsl::span<const OutputCell>,
+        std::basic_string_view<WORD>,
+        std::basic_string_view<CHAR_INFO>,
+        std::basic_string_view<OutputCell>,
         std::monostate>
         _run;
 

src/buffer/out/OutputCellRect.cpp

@@ -50,7 +50,7 @@ gsl::span<OutputCell> OutputCellRect::GetRow(const size_t row)
 // - Read-only iterator of OutputCells
 OutputCellIterator OutputCellRect::GetRowIter(const size_t row) const
 {
-    const gsl::span<const OutputCell> view(_FindRowOffset(row), _cols);
+    const std::basic_string_view<OutputCell> view(_FindRowOffset(row), _cols);
 
     return OutputCellIterator(view);
 }

src/buffer/out/TextAttribute.cpp

@@ -90,7 +90,7 @@ bool TextAttribute::IsLegacy() const noexcept
 // - reverseScreenMode: true if the screen mode is reversed.
 // Return Value:
 // - the foreground and background colors that should be displayed.
-std::pair<COLORREF, COLORREF> TextAttribute::CalculateRgbColors(const gsl::span<const COLORREF> colorTable,
+std::pair<COLORREF, COLORREF> TextAttribute::CalculateRgbColors(const std::basic_string_view<COLORREF> colorTable,
                                                                 const COLORREF defaultFgColor,
                                                                 const COLORREF defaultBgColor,
                                                                 const bool reverseScreenMode) const noexcept

src/buffer/out/TextAttribute.hpp

@@ -63,7 +63,7 @@ public:
     static TextAttribute StripErroneousVT16VersionsOfLegacyDefaults(const TextAttribute& attribute) noexcept;
     WORD GetLegacyAttributes() const noexcept;
 
-    std::pair<COLORREF, COLORREF> CalculateRgbColors(const gsl::span<const COLORREF> colorTable,
+    std::pair<COLORREF, COLORREF> CalculateRgbColors(const std::basic_string_view<COLORREF> colorTable,
                                                      const COLORREF defaultFgColor,
                                                      const COLORREF defaultBgColor,
                                                      const bool reverseScreenMode = false) const noexcept;

src/buffer/out/TextColor.cpp

@@ -138,7 +138,7 @@ void TextColor::SetDefault() noexcept
 // - brighten: if true, we'll brighten a dark color table index.
 // Return Value:
 // - a COLORREF containing the real value of this TextColor.
-COLORREF TextColor::GetColor(gsl::span<const COLORREF> colorTable,
+COLORREF TextColor::GetColor(std::basic_string_view<COLORREF> colorTable,
                              const COLORREF defaultColor,
                              bool brighten) const noexcept
 {
@@ -158,9 +158,9 @@ COLORREF TextColor::GetColor(gsl::span<const COLORREF> colorTable,
             // If we find a match, return instead the bright version of this color
             for (size_t i = 0; i < 8; i++)
             {
-                if (til::at(colorTable, i) == defaultColor)
+                if (colorTable.at(i) == defaultColor)
                 {
-                    return til::at(colorTable, i + 8);
+                    return colorTable.at(i + 8);
                 }
             }
         }
@@ -173,11 +173,11 @@ COLORREF TextColor::GetColor(gsl::span<const COLORREF> colorTable,
     }
     else if (IsIndex16() && brighten)
     {
-        return til::at(colorTable, _index | 8);
+        return colorTable.at(_index | 8);
     }
     else
     {
-        return til::at(colorTable, _index);
+        return colorTable.at(_index);
     }
 }
 

src/buffer/out/TextColor.h

@@ -88,7 +88,7 @@ public:
     void SetIndex(const BYTE index, const bool isIndex256) noexcept;
     void SetDefault() noexcept;
 
-    COLORREF GetColor(gsl::span<const COLORREF> colorTable,
+    COLORREF GetColor(std::basic_string_view<COLORREF> colorTable,
                       const COLORREF defaultColor,
                       const bool brighten = false) const noexcept;
 

src/buffer/out/ut_textbuffer/TextAttributeTests.cpp

@@ -27,7 +27,7 @@ class TextAttributeTests
     COLORREF _colorTable[COLOR_TABLE_SIZE];
     COLORREF _defaultFg = RGB(1, 2, 3);
     COLORREF _defaultBg = RGB(4, 5, 6);
-    gsl::span<const COLORREF> _GetTableView();
+    std::basic_string_view<COLORREF> _GetTableView();
 };
 
 bool TextAttributeTests::ClassSetup()
@@ -51,9 +51,9 @@ bool TextAttributeTests::ClassSetup()
     return true;
 }
 
-gsl::span<const COLORREF> TextAttributeTests::_GetTableView()
+std::basic_string_view<COLORREF> TextAttributeTests::_GetTableView()
 {
-    return gsl::span<const COLORREF>(&_colorTable[0], COLOR_TABLE_SIZE);
+    return std::basic_string_view<COLORREF>(&_colorTable[0], COLOR_TABLE_SIZE);
 }
 
 void TextAttributeTests::TestRoundtripLegacy()

src/buffer/out/ut_textbuffer/TextColorTests.cpp

@@ -27,7 +27,7 @@ class TextColorTests
     COLORREF _colorTable[COLOR_TABLE_SIZE];
     COLORREF _defaultFg = RGB(1, 2, 3);
     COLORREF _defaultBg = RGB(4, 5, 6);
-    gsl::span<const COLORREF> _GetTableView();
+    std::basic_string_view<COLORREF> _GetTableView();
 };
 
 bool TextColorTests::ClassSetup()
@@ -51,9 +51,9 @@ bool TextColorTests::ClassSetup()
     return true;
 }
 
-gsl::span<const COLORREF> TextColorTests::_GetTableView()
+std::basic_string_view<COLORREF> TextColorTests::_GetTableView()
 {
-    return gsl::span<const COLORREF>(&_colorTable[0], COLOR_TABLE_SIZE);
+    return std::basic_string_view<COLORREF>(&_colorTable[0], COLOR_TABLE_SIZE);
 }
 
 void TextColorTests::TestDefaultColor()

src/cascadia/PublicTerminalCore/HwndTerminal.cpp

@@ -16,35 +16,12 @@ using namespace ::Microsoft::Terminal::Core;
 
 static LPCWSTR term_window_class = L"HwndTerminalClass";
 
-// This magic flag is "documented" at https://msdn.microsoft.com/en-us/library/windows/desktop/ms646301(v=vs.85).aspx
-// "If the high-order bit is 1, the key is down; otherwise, it is up."
-static constexpr short KeyPressed{ gsl::narrow_cast<short>(0x8000) };
-
 static constexpr bool _IsMouseMessage(UINT uMsg)
 {
     return uMsg == WM_LBUTTONDOWN || uMsg == WM_LBUTTONUP || uMsg == WM_LBUTTONDBLCLK ||
            uMsg == WM_MBUTTONDOWN || uMsg == WM_MBUTTONUP || uMsg == WM_MBUTTONDBLCLK ||
            uMsg == WM_RBUTTONDOWN || uMsg == WM_RBUTTONUP || uMsg == WM_RBUTTONDBLCLK ||
-           uMsg == WM_MOUSEMOVE || uMsg == WM_MOUSEWHEEL || uMsg == WM_MOUSEHWHEEL;
-}
-
-// Helper static function to ensure that all ambiguous-width glyphs are reported as narrow.
-// See microsoft/terminal#2066 for more info.
-static bool _IsGlyphWideForceNarrowFallback(const std::wstring_view /* glyph */) noexcept
-{
-    return false; // glyph is not wide.
-}
-
-static bool _EnsureStaticInitialization()
-{
-    // use C++11 magic statics to make sure we only do this once.
-    static bool initialized = []() {
-        // *** THIS IS A SINGLETON ***
-        SetGlyphWidthFallback(_IsGlyphWideForceNarrowFallback);
-
-        return true;
-    }();
-    return initialized;
+           uMsg == WM_MOUSEMOVE || uMsg == WM_MOUSEWHEEL;
 }
 
 LRESULT CALLBACK HwndTerminal::HwndTerminalWndProc(
@@ -59,29 +36,10 @@ try
 
     if (terminal)
     {
-        if (_IsMouseMessage(uMsg))
+        if (_IsMouseMessage(uMsg) && terminal->_CanSendVTMouseInput())
         {
-            if (terminal->_CanSendVTMouseInput() && terminal->_SendMouseEvent(uMsg, wParam, lParam))
+            if (terminal->_SendMouseEvent(uMsg, wParam, lParam))
             {
-                // GH#6401: Capturing the mouse ensures that we get drag/release events
-                // even if the user moves outside the window.
-                // _SendMouseEvent returns false if the terminal's not in VT mode, so we'll
-                // fall through to release the capture.
-                switch (uMsg)
-                {
-                case WM_LBUTTONDOWN:
-                case WM_MBUTTONDOWN:
-                case WM_RBUTTONDOWN:
-                    SetCapture(hwnd);
-                    break;
-                case WM_LBUTTONUP:
-                case WM_MBUTTONUP:
-                case WM_RBUTTONUP:
-                    ReleaseCapture();
-                    break;
-                }
-
-                // Suppress all mouse events that made it into the terminal.
                 return 0;
             }
         }
@@ -99,10 +57,6 @@ try
             return 0;
         case WM_LBUTTONUP:
             terminal->_singleClickTouchdownPos = std::nullopt;
-            [[fallthrough]];
-        case WM_MBUTTONUP:
-        case WM_RBUTTONUP:
-            ReleaseCapture();
             break;
         case WM_MOUSEMOVE:
             if (WI_IsFlagSet(wParam, MK_LBUTTON))
@@ -118,7 +72,7 @@ try
                 {
                     const auto bufferData = terminal->_terminal->RetrieveSelectedTextFromBuffer(false);
                     LOG_IF_FAILED(terminal->_CopyTextToSystemClipboard(bufferData, true));
-                    TerminalClearSelection(terminal);
+                    terminal->_terminal->ClearSelection();
                 }
                 CATCH_LOG();
             }
@@ -127,11 +81,6 @@ try
                 terminal->_PasteTextFromClipboard();
             }
             return 0;
-        case WM_DESTROY:
-            // Release Terminal's hwnd so Teardown doesn't try to destroy it again
-            terminal->_hwnd.release();
-            terminal->Teardown();
-            return 0;
         }
     }
     return DefWindowProc(hwnd, uMsg, wParam, lParam);
@@ -165,16 +114,14 @@ static bool RegisterTermClass(HINSTANCE hInstance) noexcept
 }
 
 HwndTerminal::HwndTerminal(HWND parentHwnd) :
-    _desiredFont{ L"Consolas", 0, DEFAULT_FONT_WEIGHT, { 0, 14 }, CP_UTF8 },
-    _actualFont{ L"Consolas", 0, DEFAULT_FONT_WEIGHT, { 0, 14 }, CP_UTF8, false },
+    _desiredFont{ L"Consolas", 0, 10, { 0, 14 }, CP_UTF8 },
+    _actualFont{ L"Consolas", 0, 10, { 0, 14 }, CP_UTF8, false },
     _uiaProvider{ nullptr },
     _uiaProviderInitialized{ false },
     _currentDpi{ USER_DEFAULT_SCREEN_DPI },
     _pfnWriteCallback{ nullptr },
     _multiClickTime{ 500 } // this will be overwritten by the windows system double-click time
 {
-    _EnsureStaticInitialization();
-
     HINSTANCE hInstance = wil::GetModuleInstanceHandle();
 
     if (RegisterTermClass(hInstance))
@@ -201,11 +148,6 @@ HwndTerminal::HwndTerminal(HWND parentHwnd) :
     }
 }
 
-HwndTerminal::~HwndTerminal()
-{
-    Teardown();
-}
-
 HRESULT HwndTerminal::Initialize()
 {
     _terminal = std::make_unique<::Microsoft::Terminal::Core::Terminal>();
@@ -220,6 +162,9 @@ HRESULT HwndTerminal::Initialize()
     RETURN_IF_FAILED(dxEngine->Enable());
     _renderer->AddRenderEngine(dxEngine.get());
 
+    const auto pfn = std::bind(&::Microsoft::Console::Render::Renderer::IsGlyphWideByFont, _renderer.get(), std::placeholders::_1);
+    SetGlyphWidthFallback(pfn);
+
     _UpdateFont(USER_DEFAULT_SCREEN_DPI);
     RECT windowRect;
     GetWindowRect(_hwnd.get(), &windowRect);
@@ -236,8 +181,8 @@ HRESULT HwndTerminal::Initialize()
     _terminal->SetBackgroundCallback([](auto) {});
 
     _terminal->Create(COORD{ 80, 25 }, 1000, *_renderer);
-    _terminal->SetDefaultBackground(RGB(12, 12, 12));
-    _terminal->SetDefaultForeground(RGB(204, 204, 204));
+    _terminal->SetDefaultBackground(RGB(5, 27, 80));
+    _terminal->SetDefaultForeground(RGB(255, 255, 255));
     _terminal->SetWriteInputCallback([=](std::wstring & input) noexcept { _WriteTextToConnection(input); });
     localPointerToThread->EnablePainting();
 
@@ -246,33 +191,6 @@ HRESULT HwndTerminal::Initialize()
     return S_OK;
 }
 
-void HwndTerminal::Teardown() noexcept
-try
-{
-    // As a rule, detach resources from the Terminal before shutting them down.
-    // This ensures that teardown is reentrant.
-
-    // Shut down the renderer (and therefore the thread) before we implode
-    if (auto localRenderEngine{ std::exchange(_renderEngine, nullptr) })
-    {
-        if (auto localRenderer{ std::exchange(_renderer, nullptr) })
-        {
-            localRenderer->TriggerTeardown();
-            // renderer is destroyed
-        }
-        // renderEngine is destroyed
-    }
-
-    if (auto localHwnd{ _hwnd.release() })
-    {
-        // If we're being called through WM_DESTROY, we won't get here (hwnd is already released)
-        // If we're not, we may end up in Teardown _again_... but by the time we do, all other
-        // resources have been released and will not be released again.
-        DestroyWindow(localHwnd);
-    }
-}
-CATCH_LOG();
-
 void HwndTerminal::RegisterScrollCallback(std::function<void(int, int, int)> callback)
 {
     _terminal->SetScrollPositionChangedCallback(callback);
@@ -549,21 +467,11 @@ try
 }
 CATCH_RETURN();
 
-void HwndTerminal::_ClearSelection() noexcept
-try
-{
-    auto lock{ _terminal->LockForWriting() };
-    _terminal->ClearSelection();
-    _renderer->TriggerSelection();
-}
-CATCH_LOG();
-
 void _stdcall TerminalClearSelection(void* terminal)
 {
-    auto publicTerminal = static_cast<HwndTerminal*>(terminal);
-    publicTerminal->_ClearSelection();
+    const auto publicTerminal = static_cast<const HwndTerminal*>(terminal);
+    publicTerminal->_terminal->ClearSelection();
 }
-
 bool _stdcall TerminalIsSelectionActive(void* terminal)
 {
     const auto publicTerminal = static_cast<const HwndTerminal*>(terminal);
@@ -574,10 +482,9 @@ bool _stdcall TerminalIsSelectionActive(void* terminal)
 // Returns the selected text in the terminal.
 const wchar_t* _stdcall TerminalGetSelection(void* terminal)
 {
-    auto publicTerminal = static_cast<HwndTerminal*>(terminal);
+    const auto publicTerminal = static_cast<const HwndTerminal*>(terminal);
 
     const auto bufferData = publicTerminal->_terminal->RetrieveSelectedTextFromBuffer(false);
-    publicTerminal->_ClearSelection();
 
     // convert text: vector<string> --> string
     std::wstring selectedText;
@@ -587,6 +494,8 @@ const wchar_t* _stdcall TerminalGetSelection(void* terminal)
     }
 
     auto returnText = wil::make_cotaskmem_string_nothrow(selectedText.c_str());
+    TerminalClearSelection(terminal);
+
     return returnText.release();
 }
 
@@ -632,30 +541,19 @@ bool HwndTerminal::_CanSendVTMouseInput() const noexcept
 bool HwndTerminal::_SendMouseEvent(UINT uMsg, WPARAM wParam, LPARAM lParam) noexcept
 try
 {
-    til::point cursorPosition{
+    const til::point cursorPosition{
         GET_X_LPARAM(lParam),
         GET_Y_LPARAM(lParam),
     };
 
     const til::size fontSize{ this->_actualFont.GetSize() };
     short wheelDelta{ 0 };
-    if (uMsg == WM_MOUSEWHEEL || uMsg == WM_MOUSEHWHEEL)
+    if (uMsg == WM_MOUSEWHEEL)
     {
         wheelDelta = HIWORD(wParam);
-
-        // If it's a *WHEEL event, it's in screen coordinates, not window (?!)
-        POINT coordsToTransform = cursorPosition;
-        ScreenToClient(_hwnd.get(), &coordsToTransform);
-        cursorPosition = coordsToTransform;
     }
 
-    const TerminalInput::MouseButtonState state{
-        WI_IsFlagSet(GetKeyState(VK_LBUTTON), KeyPressed),
-        WI_IsFlagSet(GetKeyState(VK_MBUTTON), KeyPressed),
-        WI_IsFlagSet(GetKeyState(VK_RBUTTON), KeyPressed)
-    };
-
-    return _terminal->SendMouseEvent(cursorPosition / fontSize, uMsg, getControlKeyState(), wheelDelta, state);
+    return _terminal->SendMouseEvent(cursorPosition / fontSize, uMsg, getControlKeyState(), wheelDelta);
 }
 catch (...)
 {
@@ -663,24 +561,20 @@ catch (...)
     return false;
 }
 
-void HwndTerminal::_SendKeyEvent(WORD vkey, WORD scanCode, WORD flags, bool keyDown) noexcept
+void HwndTerminal::_SendKeyEvent(WORD vkey, WORD scanCode, bool keyDown) noexcept
 try
 {
-    auto modifiers = getControlKeyState();
-    if (WI_IsFlagSet(flags, ENHANCED_KEY))
-    {
-        modifiers |= ControlKeyStates::EnhancedKey;
-    }
-    _terminal->SendKeyEvent(vkey, scanCode, modifiers, keyDown);
+    const auto flags = getControlKeyState();
+    _terminal->SendKeyEvent(vkey, scanCode, flags, keyDown);
 }
 CATCH_LOG();
 
-void HwndTerminal::_SendCharEvent(wchar_t ch, WORD scanCode, WORD flags) noexcept
+void HwndTerminal::_SendCharEvent(wchar_t ch, WORD scanCode) noexcept
 try
 {
     if (_terminal->IsSelectionActive())
     {
-        _ClearSelection();
+        _terminal->ClearSelection();
         if (ch == UNICODE_ESC)
         {
             // ESC should clear any selection before it triggers input.
@@ -695,25 +589,21 @@ try
         return;
     }
 
-    auto modifiers = getControlKeyState();
-    if (WI_IsFlagSet(flags, ENHANCED_KEY))
-    {
-        modifiers |= ControlKeyStates::EnhancedKey;
-    }
-    _terminal->SendCharEvent(ch, scanCode, modifiers);
+    const auto flags = getControlKeyState();
+    _terminal->SendCharEvent(ch, scanCode, flags);
 }
 CATCH_LOG();
 
-void _stdcall TerminalSendKeyEvent(void* terminal, WORD vkey, WORD scanCode, WORD flags, bool keyDown)
+void _stdcall TerminalSendKeyEvent(void* terminal, WORD vkey, WORD scanCode, bool keyDown)
 {
     const auto publicTerminal = static_cast<HwndTerminal*>(terminal);
-    publicTerminal->_SendKeyEvent(vkey, scanCode, flags, keyDown);
+    publicTerminal->_SendKeyEvent(vkey, scanCode, keyDown);
 }
 
-void _stdcall TerminalSendCharEvent(void* terminal, wchar_t ch, WORD scanCode, WORD flags)
+void _stdcall TerminalSendCharEvent(void* terminal, wchar_t ch, WORD scanCode)
 {
     const auto publicTerminal = static_cast<HwndTerminal*>(terminal);
-    publicTerminal->_SendCharEvent(ch, scanCode, flags);
+    publicTerminal->_SendCharEvent(ch, scanCode);
 }
 
 void _stdcall DestroyTerminal(void* terminal)
@@ -742,7 +632,7 @@ void _stdcall TerminalSetTheme(void* terminal, TerminalTheme theme, LPCWSTR font
 
     publicTerminal->_terminal->SetCursorStyle(theme.CursorStyle);
 
-    publicTerminal->_desiredFont = { fontFamily, 0, DEFAULT_FONT_WEIGHT, { 0, fontSize }, CP_UTF8 };
+    publicTerminal->_desiredFont = { fontFamily, 0, 10, { 0, fontSize }, CP_UTF8 };
     publicTerminal->_UpdateFont(newDpi);
 
     // When the font changes the terminal dimensions need to be recalculated since the available row and column

src/cascadia/PublicTerminalCore/HwndTerminal.hpp

@@ -34,8 +34,8 @@ __declspec(dllexport) bool _stdcall TerminalIsSelectionActive(void* terminal);
 __declspec(dllexport) void _stdcall DestroyTerminal(void* terminal);
 __declspec(dllexport) void _stdcall TerminalSetTheme(void* terminal, TerminalTheme theme, LPCWSTR fontFamily, short fontSize, int newDpi);
 __declspec(dllexport) void _stdcall TerminalRegisterWriteCallback(void* terminal, const void __stdcall callback(wchar_t*));
-__declspec(dllexport) void _stdcall TerminalSendKeyEvent(void* terminal, WORD vkey, WORD scanCode, WORD flags, bool keyDown);
-__declspec(dllexport) void _stdcall TerminalSendCharEvent(void* terminal, wchar_t ch, WORD flags, WORD scanCode);
+__declspec(dllexport) void _stdcall TerminalSendKeyEvent(void* terminal, WORD vkey, WORD scanCode, bool keyDown);
+__declspec(dllexport) void _stdcall TerminalSendCharEvent(void* terminal, wchar_t ch, WORD scanCode);
 __declspec(dllexport) void _stdcall TerminalBlinkCursor(void* terminal);
 __declspec(dllexport) void _stdcall TerminalSetCursorVisible(void* terminal, const bool visible);
 __declspec(dllexport) void _stdcall TerminalSetFocus(void* terminal);
@@ -51,10 +51,9 @@ public:
     HwndTerminal(HwndTerminal&&) = default;
     HwndTerminal& operator=(const HwndTerminal&) = default;
     HwndTerminal& operator=(HwndTerminal&&) = default;
-    ~HwndTerminal();
+    ~HwndTerminal() = default;
 
     HRESULT Initialize();
-    void Teardown() noexcept;
     void SendOutput(std::wstring_view data);
     HRESULT Refresh(const SIZE windowSize, _Out_ COORD* dimensions);
     void RegisterScrollCallback(std::function<void(int, int, int)> callback);
@@ -93,8 +92,8 @@ private:
     friend void _stdcall TerminalClearSelection(void* terminal);
     friend const wchar_t* _stdcall TerminalGetSelection(void* terminal);
     friend bool _stdcall TerminalIsSelectionActive(void* terminal);
-    friend void _stdcall TerminalSendKeyEvent(void* terminal, WORD vkey, WORD scanCode, WORD flags, bool keyDown);
-    friend void _stdcall TerminalSendCharEvent(void* terminal, wchar_t ch, WORD scanCode, WORD flags);
+    friend void _stdcall TerminalSendKeyEvent(void* terminal, WORD vkey, WORD scanCode, bool keyDown);
+    friend void _stdcall TerminalSendCharEvent(void* terminal, wchar_t ch, WORD scanCode);
     friend void _stdcall TerminalSetTheme(void* terminal, TerminalTheme theme, LPCWSTR fontFamily, short fontSize, int newDpi);
     friend void _stdcall TerminalBlinkCursor(void* terminal);
     friend void _stdcall TerminalSetCursorVisible(void* terminal, const bool visible);
@@ -113,13 +112,11 @@ private:
     HRESULT _MoveSelection(LPARAM lParam) noexcept;
     IRawElementProviderSimple* _GetUiaProvider() noexcept;
 
-    void _ClearSelection() noexcept;
-
     bool _CanSendVTMouseInput() const noexcept;
     bool _SendMouseEvent(UINT uMsg, WPARAM wParam, LPARAM lParam) noexcept;
 
-    void _SendKeyEvent(WORD vkey, WORD scanCode, WORD flags, bool keyDown) noexcept;
-    void _SendCharEvent(wchar_t ch, WORD scanCode, WORD flags) noexcept;
+    void _SendKeyEvent(WORD vkey, WORD scanCode, bool keyDown) noexcept;
+    void _SendCharEvent(wchar_t ch, WORD scanCode) noexcept;
 
     // Inherited via IControlAccessibilityInfo
     COORD GetFontSize() const override;

src/cascadia/TerminalApp/CascadiaSettings.cpp

@@ -93,7 +93,7 @@ const Profile* CascadiaSettings::FindProfile(GUID profileGuid) const noexcept
 // - <none>
 // Return Value:
 // - an iterable collection of all of our Profiles.
-gsl::span<const Profile> CascadiaSettings::GetProfiles() const noexcept
+std::basic_string_view<Profile> CascadiaSettings::GetProfiles() const noexcept
 {
     return { &_profiles[0], _profiles.size() };
 }
@@ -226,12 +226,9 @@ void CascadiaSettings::_ValidateProfilesHaveGuid()
 void CascadiaSettings::_ResolveDefaultProfile()
 {
     const auto unparsedDefaultProfile{ GlobalSettings().UnparsedDefaultProfile() };
-    if (unparsedDefaultProfile)
-    {
-        auto maybeParsedDefaultProfile{ _GetProfileGuidByName(*unparsedDefaultProfile) };
-        auto defaultProfileGuid{ Utils::CoalesceOptionals(maybeParsedDefaultProfile, GUID{}) };
-        GlobalSettings().DefaultProfile(defaultProfileGuid);
-    }
+    auto maybeParsedDefaultProfile{ _GetProfileGuidByName(unparsedDefaultProfile) };
+    auto defaultProfileGuid{ Utils::CoalesceOptionals(maybeParsedDefaultProfile, GUID{}) };
+    GlobalSettings().DefaultProfile(defaultProfileGuid);
 }
 
 // Method Description:

src/cascadia/TerminalApp/CascadiaSettings.h

@@ -59,7 +59,7 @@ public:
 
     GlobalAppSettings& GlobalSettings();
 
-    gsl::span<const Profile> GetProfiles() const noexcept;
+    std::basic_string_view<Profile> GetProfiles() const noexcept;
 
     winrt::TerminalApp::AppKeyBindings GetKeybindings() const noexcept;
 

src/cascadia/TerminalApp/CascadiaSettingsSerialization.cpp

@@ -61,7 +61,7 @@ std::unique_ptr<CascadiaSettings> CascadiaSettings::LoadAll()
     // GH 3588, we need this below to know if the user chose something that wasn't our default.
     // Collect it up here in case it gets modified by any of the other layers between now and when
     // the user's preferences are loaded and layered.
-    const auto hardcodedDefaultGuid = resultPtr->GlobalSettings().DefaultProfile();
+    const auto hardcodedDefaultGuid = resultPtr->GlobalSettings().UnparsedDefaultProfile();
 
     std::optional<std::string> fileData = _ReadUserSettings();
     const bool foundFile = fileData.has_value();
@@ -141,11 +141,12 @@ std::unique_ptr<CascadiaSettings> CascadiaSettings::LoadAll()
     // is a lot of computation we can skip if no one cares.
     if (TraceLoggingProviderEnabled(g_hTerminalAppProvider, 0, MICROSOFT_KEYWORD_MEASURES))
     {
+        const auto hardcodedDefaultGuidAsGuid = Utils::GuidFromString(hardcodedDefaultGuid);
         const auto guid = resultPtr->GlobalSettings().DefaultProfile();
 
         // Compare to the defaults.json one that we set on install.
         // If it's different, log what the user chose.
-        if (hardcodedDefaultGuid != guid)
+        if (hardcodedDefaultGuidAsGuid != guid)
         {
             TraceLoggingWrite(
                 g_hTerminalAppProvider, // handle to TerminalApp tracelogging provider
@@ -228,7 +229,6 @@ std::unique_ptr<CascadiaSettings> CascadiaSettings::LoadDefaults()
     // them from a file (and the potential that could fail)
     resultPtr->_ParseJsonString(DefaultJson, true);
     resultPtr->LayerJson(resultPtr->_defaultSettings);
-    resultPtr->_ResolveDefaultProfile();
 
     return resultPtr;
 }

src/cascadia/TerminalApp/CommandPalette.cpp

@@ -187,16 +187,14 @@ namespace winrt::TerminalApp::implementation
         {
             const auto actionAndArgs = command.Action();
             _dispatch.DoAction(actionAndArgs);
+            _close();
 
             TraceLoggingWrite(
                 g_hTerminalAppProvider, // handle to TerminalApp tracelogging provider
                 "CommandPaletteDispatchedAction",
                 TraceLoggingDescription("Event emitted when the user selects an action in the Command Palette"),
-                TraceLoggingUInt32(_searchBox().Text().size(), "SearchTextLength", "Number of characters in the search string"),
                 TraceLoggingKeyword(MICROSOFT_KEYWORD_MEASURES),
                 TelemetryPrivacyDataTag(PDT_ProductAndServicePerformance));
-
-            _close();
         }
     }
 
@@ -273,17 +271,16 @@ namespace winrt::TerminalApp::implementation
     };
 
     // Method Description:
-    // - Produce a list of filtered actions to reflect the current contents of
+    // - Update our list of filtered actions to reflect the current contents of
     //   the input box. For more details on which commands will be displayed,
     //   see `_getWeight`.
     // Arguments:
-    // - A collection that will receive the filtered actions
+    // - <none>
     // Return Value:
     // - <none>
-    std::vector<winrt::TerminalApp::Command> CommandPalette::_collectFilteredActions()
+    void CommandPalette::_updateFilteredActions()
     {
-        std::vector<winrt::TerminalApp::Command> actions;
-
+        _filteredActions.Clear();
         auto searchText = _searchBox().Text();
         const bool addAll = searchText.empty();
 
@@ -306,10 +303,10 @@ namespace winrt::TerminalApp::implementation
 
             for (auto action : sortedCommands)
             {
-                actions.push_back(action);
+                _filteredActions.Append(action);
             }
 
-            return actions;
+            return;
         }
 
         // Here, there was some filter text.
@@ -346,56 +343,7 @@ namespace winrt::TerminalApp::implementation
         {
             auto top = heap.top();
             heap.pop();
-            actions.push_back(top.command);
-        }
-
-        return actions;
-    }
-
-    // Method Description:
-    // - Update our list of filtered actions to reflect the current contents of
-    //   the input box. For more details on which commands will be displayed,
-    //   see `_getWeight`.
-    // Arguments:
-    // - <none>
-    // Return Value:
-    // - <none>
-    void CommandPalette::_updateFilteredActions()
-    {
-        auto actions = _collectFilteredActions();
-
-        // Make _filteredActions look identical to actions, using only Insert and Remove.
-        // This allows WinUI to nicely animate the ListView as it changes.
-        for (uint32_t i = 0; i < _filteredActions.Size() && i < actions.size(); i++)
-        {
-            for (uint32_t j = i; j < _filteredActions.Size(); j++)
-            {
-                if (_filteredActions.GetAt(j) == actions[i])
-                {
-                    for (uint32_t k = i; k < j; k++)
-                    {
-                        _filteredActions.RemoveAt(i);
-                    }
-                    break;
-                }
-            }
-
-            if (_filteredActions.GetAt(i) != actions[i])
-            {
-                _filteredActions.InsertAt(i, actions[i]);
-            }
-        }
-
-        // Remove any extra trailing items from the destination
-        while (_filteredActions.Size() > actions.size())
-        {
-            _filteredActions.RemoveAtEnd();
-        }
-
-        // Add any extra trailing items from the source
-        while (_filteredActions.Size() < actions.size())
-        {
-            _filteredActions.Append(actions[_filteredActions.Size()]);
+            _filteredActions.Append(top.command);
         }
     }
 

src/cascadia/TerminalApp/CommandPalette.h

@@ -37,7 +37,6 @@ namespace winrt::TerminalApp::implementation
         void _selectNextItem(const bool moveDown);
 
         void _updateFilteredActions();
-        std::vector<winrt::TerminalApp::Command> _collectFilteredActions();
         static int _getWeight(const winrt::hstring& searchText, const winrt::hstring& name);
         void _close();
 

src/cascadia/TerminalApp/GlobalAppSettings.cpp

@@ -105,9 +105,9 @@ GUID GlobalAppSettings::DefaultProfile() const
     return _defaultProfile;
 }
 
-std::optional<std::wstring> GlobalAppSettings::UnparsedDefaultProfile() const
+std::wstring GlobalAppSettings::UnparsedDefaultProfile() const
 {
-    return _unparsedDefaultProfile;
+    return _unparsedDefaultProfile.value();
 }
 
 AppKeyBindings GlobalAppSettings::GetKeybindings() const noexcept

src/cascadia/TerminalApp/GlobalAppSettings.h

@@ -61,7 +61,7 @@ public:
     // by higher layers in the app.
     void DefaultProfile(const GUID defaultProfile) noexcept;
     GUID DefaultProfile() const;
-    std::optional<std::wstring> UnparsedDefaultProfile() const;
+    std::wstring UnparsedDefaultProfile() const;
 
     GETSET_PROPERTY(int32_t, InitialRows); // default value set in constructor
     GETSET_PROPERTY(int32_t, InitialCols); // default value set in constructor

src/cascadia/TerminalApp/TerminalPage.cpp

@@ -166,28 +166,7 @@ namespace winrt::TerminalApp::implementation
         _newTabButton.Click([weakThis{ get_weak() }](auto&&, auto&&) {
             if (auto page{ weakThis.get() })
             {
-                // if alt is pressed, open a pane
-                const CoreWindow window = CoreWindow::GetForCurrentThread();
-                const auto rAltState = window.GetKeyState(VirtualKey::RightMenu);
-                const auto lAltState = window.GetKeyState(VirtualKey::LeftMenu);
-                const bool altPressed = WI_IsFlagSet(lAltState, CoreVirtualKeyStates::Down) ||
-                                        WI_IsFlagSet(rAltState, CoreVirtualKeyStates::Down);
-
-                // Check for DebugTap
-                bool debugTap = page->_settings->GlobalSettings().DebugFeaturesEnabled() &&
-                                WI_IsFlagSet(lAltState, CoreVirtualKeyStates::Down) &&
-                                WI_IsFlagSet(rAltState, CoreVirtualKeyStates::Down);
-
-                if (altPressed && !debugTap)
-                {
-                    page->_SplitPane(TerminalApp::SplitState::Automatic,
-                                     TerminalApp::SplitType::Manual,
-                                     nullptr);
-                }
-                else
-                {
-                    page->_OpenNewTab(nullptr);
-                }
+                page->_OpenNewTab(nullptr);
             }
         });
         _tabView.SelectionChanged({ this, &TerminalPage::_OnTabSelectionChanged });
@@ -1799,7 +1778,7 @@ namespace winrt::TerminalApp::implementation
                 tab->SetFocused(true);
 
                 // Raise an event that our title changed
-                _titleChangeHandlers(*this, tab->GetActiveTitle());
+                _titleChangeHandlers(*this, Title());
 
                 // Raise an event that our titlebar color changed
                 std::optional<Windows::UI::Color> color = tab->GetTabColor();

src/cascadia/TerminalApp/defaults.json

@@ -187,7 +187,7 @@
             "foreground": "#839496",
             "background": "#002B36",
             "cursorColor": "#FFFFFF",
-            "black": "#002B36",
+            "black": "#073642",
             "red": "#DC322F",
             "green": "#859900",
             "yellow": "#B58900",
@@ -195,7 +195,7 @@
             "purple": "#D33682",
             "cyan": "#2AA198",
             "white": "#EEE8D5",
-            "brightBlack": "#073642",
+            "brightBlack": "#002B36",
             "brightRed": "#CB4B16",
             "brightGreen": "#586E75",
             "brightYellow": "#657B83",
@@ -209,7 +209,7 @@
             "foreground": "#657B83",
             "background": "#FDF6E3",
             "cursorColor": "#002B36",
-            "black": "#002B36",
+            "black": "#073642",
             "red": "#DC322F",
             "green": "#859900",
             "yellow": "#B58900",
@@ -217,7 +217,7 @@
             "purple": "#D33682",
             "cyan": "#2AA198",
             "white": "#EEE8D5",
-            "brightBlack": "#073642",
+            "brightBlack": "#002B36",
             "brightRed": "#CB4B16",
             "brightGreen": "#586E75",
             "brightYellow": "#657B83",

src/cascadia/TerminalControl/IMouseWheelListener.idl

@@ -11,6 +11,6 @@ namespace Microsoft.Terminal.TerminalControl
     [uuid("65b8b8c5-988f-43ff-aba9-e89368da1598")]
     interface IMouseWheelListener
     {
-        Boolean OnMouseWheel(Windows.Foundation.Point coord, Int32 delta, Boolean leftButtonDown, Boolean midButtonDown, Boolean rightButtonDown);
+        Boolean OnMouseWheel(Windows.Foundation.Point coord, Int32 delta);
     }
 }

src/cascadia/TerminalControl/TermControl.cpp

@@ -16,7 +16,6 @@
 #include "TermControlAutomationPeer.h"
 
 using namespace ::Microsoft::Console::Types;
-using namespace ::Microsoft::Console::VirtualTerminal;
 using namespace ::Microsoft::Terminal::Core;
 using namespace winrt::Windows::UI::Xaml;
 using namespace winrt::Windows::UI::Xaml::Input;
@@ -738,11 +737,7 @@ namespace winrt::Microsoft::Terminal::TerminalControl::implementation
 
         const auto ch = e.Character();
         const auto scanCode = gsl::narrow_cast<WORD>(e.KeyStatus().ScanCode);
-        auto modifiers = _GetPressedModifierKeys();
-        if (e.KeyStatus().IsExtendedKey)
-        {
-            modifiers |= ControlKeyStates::EnhancedKey;
-        }
+        const auto modifiers = _GetPressedModifierKeys();
         const bool handled = _terminal->SendCharEvent(ch, scanCode, modifiers);
         e.Handled(handled);
     }
@@ -831,13 +826,9 @@ namespace winrt::Microsoft::Terminal::TerminalControl::implementation
             return;
         }
 
-        auto modifiers = _GetPressedModifierKeys();
+        const auto modifiers = _GetPressedModifierKeys();
         const auto vkey = gsl::narrow_cast<WORD>(e.OriginalKey());
         const auto scanCode = gsl::narrow_cast<WORD>(e.KeyStatus().ScanCode);
-        if (e.KeyStatus().IsExtendedKey)
-        {
-            modifiers |= ControlKeyStates::EnhancedKey;
-        }
 
         // Alt-Numpad# input will send us a character once the user releases
         // Alt, so we should be ignoring the individual keydowns. The character
@@ -1010,8 +1001,7 @@ namespace winrt::Microsoft::Terminal::TerminalControl::implementation
         }
 
         const auto modifiers = _GetPressedModifierKeys();
-        const TerminalInput::MouseButtonState state{ props.IsLeftButtonPressed(), props.IsMiddleButtonPressed(), props.IsRightButtonPressed() };
-        return _terminal->SendMouseEvent(terminalPosition, uiButton, modifiers, sWheelDelta, state);
+        return _terminal->SendMouseEvent(terminalPosition, uiButton, modifiers, sWheelDelta);
     }
 
     // Method Description:
@@ -1335,12 +1325,10 @@ namespace winrt::Microsoft::Terminal::TerminalControl::implementation
         }
 
         const auto point = args.GetCurrentPoint(*this);
-        const auto props = point.Properties();
-        const TerminalInput::MouseButtonState state{ props.IsLeftButtonPressed(), props.IsMiddleButtonPressed(), props.IsRightButtonPressed() };
         auto result = _DoMouseWheel(point.Position(),
                                     ControlKeyStates{ args.KeyModifiers() },
                                     point.Properties().MouseWheelDelta(),
-                                    state);
+                                    point.Properties().IsLeftButtonPressed());
         if (result)
         {
             args.Handled(true);
@@ -1363,7 +1351,7 @@ namespace winrt::Microsoft::Terminal::TerminalControl::implementation
     bool TermControl::_DoMouseWheel(const Windows::Foundation::Point point,
                                     const ControlKeyStates modifiers,
                                     const int32_t delta,
-                                    const TerminalInput::MouseButtonState state)
+                                    const bool isLeftButtonPressed)
     {
         if (_CanSendVTMouseInput())
         {
@@ -1375,8 +1363,7 @@ namespace winrt::Microsoft::Terminal::TerminalControl::implementation
             return _terminal->SendMouseEvent(_GetTerminalPosition(point),
                                              WM_MOUSEWHEEL,
                                              _GetPressedModifierKeys(),
-                                             ::base::saturated_cast<short>(delta),
-                                             state);
+                                             ::base::saturated_cast<short>(delta));
         }
 
         const auto ctrlPressed = modifiers.IsCtrlPressed();
@@ -1392,7 +1379,7 @@ namespace winrt::Microsoft::Terminal::TerminalControl::implementation
         }
         else
         {
-            _MouseScrollHandler(delta, point, state.isLeftButtonDown);
+            _MouseScrollHandler(delta, point, isLeftButtonPressed);
         }
         return false;
     }
@@ -1406,16 +1393,11 @@ namespace winrt::Microsoft::Terminal::TerminalControl::implementation
     // - location: the location of the mouse during this event. This location is
     //   relative to the origin of the control
     // - delta: the mouse wheel delta that triggered this event.
-    // - state: the state for each of the mouse buttons individually (pressed/unpressed)
     bool TermControl::OnMouseWheel(const Windows::Foundation::Point location,
-                                   const int32_t delta,
-                                   const bool leftButtonDown,
-                                   const bool midButtonDown,
-                                   const bool rightButtonDown)
+                                   const int32_t delta)
     {
         const auto modifiers = _GetPressedModifierKeys();
-        TerminalInput::MouseButtonState state{ leftButtonDown, midButtonDown, rightButtonDown };
-        return _DoMouseWheel(location, modifiers, delta, state);
+        return _DoMouseWheel(location, modifiers, delta, false);
     }
 
     // Method Description:

src/cascadia/TerminalControl/TermControl.h

@@ -17,11 +17,6 @@
 #include "SearchBoxControl.h"
 #include "ThrottledFunc.h"
 
-namespace Microsoft::Console::VirtualTerminal
-{
-    struct MouseButtonState;
-}
-
 namespace winrt::Microsoft::Terminal::TerminalControl::implementation
 {
     struct CopyToClipboardEventArgs :
@@ -94,7 +89,7 @@ namespace winrt::Microsoft::Terminal::TerminalControl::implementation
 
         bool OnDirectKeyEvent(const uint32_t vkey, const bool down);
 
-        bool OnMouseWheel(const Windows::Foundation::Point location, const int32_t delta, const bool leftButtonDown, const bool midButtonDown, const bool rightButtonDown);
+        bool OnMouseWheel(const Windows::Foundation::Point location, const int32_t delta);
 
         ~TermControl();
 
@@ -226,7 +221,7 @@ namespace winrt::Microsoft::Terminal::TerminalControl::implementation
         void _MouseScrollHandler(const double mouseDelta, const Windows::Foundation::Point point, const bool isLeftButtonPressed);
         void _MouseZoomHandler(const double delta);
         void _MouseTransparencyHandler(const double delta);
-        bool _DoMouseWheel(const Windows::Foundation::Point point, const ::Microsoft::Terminal::Core::ControlKeyStates modifiers, const int32_t delta, const ::Microsoft::Console::VirtualTerminal::TerminalInput::MouseButtonState state);
+        bool _DoMouseWheel(const Windows::Foundation::Point point, const ::Microsoft::Terminal::Core::ControlKeyStates modifiers, const int32_t delta, const bool isLeftButtonPressed);
 
         bool _CapturePointer(Windows::Foundation::IInspectable const& sender, Windows::UI::Xaml::Input::PointerRoutedEventArgs const& e);
         bool _ReleasePointerCapture(Windows::Foundation::IInspectable const& sender, Windows::UI::Xaml::Input::PointerRoutedEventArgs const& e);

src/cascadia/TerminalCore/ITerminalApi.hpp

@@ -39,7 +39,6 @@ namespace Microsoft::Terminal::Core
         virtual bool SetColorTableEntry(const size_t tableIndex, const DWORD color) noexcept = 0;
 
         virtual bool SetCursorStyle(const ::Microsoft::Console::VirtualTerminal::DispatchTypes::CursorStyle cursorStyle) noexcept = 0;
-        virtual bool SetCursorColor(const DWORD color) noexcept = 0;
 
         virtual bool SetDefaultForeground(const DWORD color) noexcept = 0;
         virtual bool SetDefaultBackground(const DWORD color) noexcept = 0;

src/cascadia/TerminalCore/ITerminalInput.hpp

@@ -17,7 +17,7 @@ namespace Microsoft::Terminal::Core
         ITerminalInput& operator=(ITerminalInput&&) = default;
 
         virtual bool SendKeyEvent(const WORD vkey, const WORD scanCode, const ControlKeyStates states, const bool keyDown) = 0;
-        virtual bool SendMouseEvent(const COORD viewportPos, const unsigned int uiButton, const ControlKeyStates states, const short wheelDelta, const Microsoft::Console::VirtualTerminal::TerminalInput::MouseButtonState state) = 0;
+        virtual bool SendMouseEvent(const COORD viewportPos, const unsigned int uiButton, const ControlKeyStates states, const short wheelDelta) = 0;
         virtual bool SendCharEvent(const wchar_t ch, const WORD scanCode, const ControlKeyStates states) = 0;
 
         // void SendMouseEvent(uint row, uint col, KeyModifiers modifiers);

src/cascadia/TerminalCore/Terminal.cpp

@@ -430,19 +430,6 @@ bool Terminal::SendKeyEvent(const WORD vkey,
 
     _StoreKeyEvent(vkey, scanCode);
 
-    // As a Terminal we're mostly interested in getting key events from physical hardware (mouse & keyboard).
-    // We're thus ignoring events whose values are outside the valid range and unlikely to be generated by the current keyboard.
-    // It's very likely that a proper followup character event will be sent to us.
-    // This prominently happens using AutoHotKey's keyboard remapping feature,
-    // which sends input events whose vkey is 0xff and scanCode is 0.
-    // We need to check for this early, as _CharacterFromKeyEvent() always returns 0 for such invalid values,
-    // making us believe that this is an actual non-character input, while it usually isn't.
-    // GH#7064
-    if (vkey == 0 || vkey >= 0xff || scanCode == 0)
-    {
-        return false;
-    }
-
     const auto isAltOnlyPressed = states.IsAltPressed() && !states.IsCtrlPressed();
     const auto isSuppressedAltGrAlias = !_altGrAliasing && states.IsAltPressed() && states.IsCtrlPressed();
 
@@ -497,16 +484,16 @@ bool Terminal::SendKeyEvent(const WORD vkey,
 // Return Value:
 // - true if we translated the key event, and it should not be processed any further.
 // - false if we did not translate the key, and it should be processed into a character.
-bool Terminal::SendMouseEvent(const COORD viewportPos, const unsigned int uiButton, const ControlKeyStates states, const short wheelDelta, const TerminalInput::MouseButtonState state)
+bool Terminal::SendMouseEvent(const COORD viewportPos, const unsigned int uiButton, const ControlKeyStates states, const short wheelDelta)
 {
-    // GH#6401: VT applications should be able to receive mouse events from outside the
-    // terminal buffer. This is likely to happen when the user drags the cursor offscreen.
-    // We shouldn't throw away perfectly good events when they're offscreen, so we just
-    // clamp them to be within the range [(0, 0), (W, H)].
-#pragma warning(suppress : 26496) // analysis can't tell we're assigning through a reference below
-    auto clampedPos{ viewportPos };
-    _mutableViewport.ToOrigin().Clamp(clampedPos);
-    return _terminalInput->HandleMouse(clampedPos, uiButton, GET_KEYSTATE_WPARAM(states.Value()), wheelDelta, state);
+    // viewportPos must be within the dimensions of the viewport
+    const auto viewportDimensions = _mutableViewport.Dimensions();
+    if (viewportPos.X < 0 || viewportPos.X >= viewportDimensions.X || viewportPos.Y < 0 || viewportPos.Y >= viewportDimensions.Y)
+    {
+        return false;
+    }
+
+    return _terminalInput->HandleMouse(viewportPos, uiButton, GET_KEYSTATE_WPARAM(states.Value()), wheelDelta);
 }
 
 // Method Description:

src/cascadia/TerminalCore/Terminal.hpp

@@ -93,7 +93,6 @@ public:
     bool SetWindowTitle(std::wstring_view title) noexcept override;
     bool SetColorTableEntry(const size_t tableIndex, const COLORREF color) noexcept override;
     bool SetCursorStyle(const ::Microsoft::Console::VirtualTerminal::DispatchTypes::CursorStyle cursorStyle) noexcept override;
-    bool SetCursorColor(const COLORREF color) noexcept override;
     bool SetDefaultForeground(const COLORREF color) noexcept override;
     bool SetDefaultBackground(const COLORREF color) noexcept override;
 
@@ -116,7 +115,7 @@ public:
 #pragma region ITerminalInput
     // These methods are defined in Terminal.cpp
     bool SendKeyEvent(const WORD vkey, const WORD scanCode, const Microsoft::Terminal::Core::ControlKeyStates states, const bool keyDown) override;
-    bool SendMouseEvent(const COORD viewportPos, const unsigned int uiButton, const ControlKeyStates states, const short wheelDelta, const Microsoft::Console::VirtualTerminal::TerminalInput::MouseButtonState state) override;
+    bool SendMouseEvent(const COORD viewportPos, const unsigned int uiButton, const ControlKeyStates states, const short wheelDelta) override;
     bool SendCharEvent(const wchar_t ch, const WORD scanCode, const ControlKeyStates states) override;
 
     [[nodiscard]] HRESULT UserResize(const COORD viewportSize) noexcept override;

src/cascadia/TerminalCore/TerminalApi.cpp

@@ -64,14 +64,6 @@ COORD Terminal::GetCursorPosition() noexcept
     return newPos;
 }
 
-bool Terminal::SetCursorColor(const COLORREF color) noexcept
-try
-{
-    _buffer->GetCursor().SetColor(color);
-    return true;
-}
-CATCH_LOG_RETURN_FALSE()
-
 // Method Description:
 // - Moves the cursor down one line, and possibly also to the leftmost column.
 // Arguments:

src/cascadia/TerminalCore/TerminalDispatch.cpp

@@ -146,13 +146,6 @@ try
 }
 CATCH_LOG_RETURN_FALSE()
 
-bool TerminalDispatch::SetCursorColor(const DWORD color) noexcept
-try
-{
-    return _terminalApi.SetCursorColor(color);
-}
-CATCH_LOG_RETURN_FALSE()
-
 bool TerminalDispatch::SetClipboard(std::wstring_view content) noexcept
 try
 {
@@ -361,12 +354,12 @@ bool TerminalDispatch::EnableAlternateScroll(const bool enabled) noexcept
     return true;
 }
 
-bool TerminalDispatch::SetPrivateModes(const gsl::span<const DispatchTypes::PrivateModeParams> params) noexcept
+bool TerminalDispatch::SetPrivateModes(const std::basic_string_view<DispatchTypes::PrivateModeParams> params) noexcept
 {
     return _SetResetPrivateModes(params, true);
 }
 
-bool TerminalDispatch::ResetPrivateModes(const gsl::span<const DispatchTypes::PrivateModeParams> params) noexcept
+bool TerminalDispatch::ResetPrivateModes(const std::basic_string_view<DispatchTypes::PrivateModeParams> params) noexcept
 {
     return _SetResetPrivateModes(params, false);
 }
@@ -381,7 +374,7 @@ bool TerminalDispatch::ResetPrivateModes(const gsl::span<const DispatchTypes::Pr
 // - enable - True for set, false for unset.
 // Return Value:
 // - True if ALL params were handled successfully. False otherwise.
-bool TerminalDispatch::_SetResetPrivateModes(const gsl::span<const DispatchTypes::PrivateModeParams> params, const bool enable) noexcept
+bool TerminalDispatch::_SetResetPrivateModes(const std::basic_string_view<DispatchTypes::PrivateModeParams> params, const bool enable) noexcept
 {
     // because the user might chain together params we don't support with params we DO support, execute all
     // params in the sequence, and only return failure if we failed at least one of them

src/cascadia/TerminalCore/TerminalDispatch.hpp

@@ -13,7 +13,7 @@ public:
     void Print(const wchar_t wchPrintable) noexcept override;
     void PrintString(const std::wstring_view string) noexcept override;
 
-    bool SetGraphicsRendition(const gsl::span<const ::Microsoft::Console::VirtualTerminal::DispatchTypes::GraphicsOptions> options) noexcept override;
+    bool SetGraphicsRendition(const std::basic_string_view<::Microsoft::Console::VirtualTerminal::DispatchTypes::GraphicsOptions> options) noexcept override;
 
     bool CursorPosition(const size_t line,
                         const size_t column) noexcept override; // CUP
@@ -35,7 +35,6 @@ public:
 
     bool SetColorTableEntry(const size_t tableIndex, const DWORD color) noexcept override;
     bool SetCursorStyle(const ::Microsoft::Console::VirtualTerminal::DispatchTypes::CursorStyle cursorStyle) noexcept override;
-    bool SetCursorColor(const DWORD color) noexcept override;
 
     bool SetClipboard(std::wstring_view content) noexcept override;
 
@@ -60,16 +59,16 @@ public:
     bool EnableAnyEventMouseMode(const bool enabled) noexcept override; // ?1003
     bool EnableAlternateScroll(const bool enabled) noexcept override; // ?1007
 
-    bool SetPrivateModes(const gsl::span<const ::Microsoft::Console::VirtualTerminal::DispatchTypes::PrivateModeParams> /*params*/) noexcept override; // DECSET
-    bool ResetPrivateModes(const gsl::span<const ::Microsoft::Console::VirtualTerminal::DispatchTypes::PrivateModeParams> /*params*/) noexcept override; // DECRST
+    bool SetPrivateModes(const std::basic_string_view<::Microsoft::Console::VirtualTerminal::DispatchTypes::PrivateModeParams> /*params*/) noexcept override; // DECSET
+    bool ResetPrivateModes(const std::basic_string_view<::Microsoft::Console::VirtualTerminal::DispatchTypes::PrivateModeParams> /*params*/) noexcept override; // DECRST
 
 private:
     ::Microsoft::Terminal::Core::ITerminalApi& _terminalApi;
 
-    size_t _SetRgbColorsHelper(const gsl::span<const ::Microsoft::Console::VirtualTerminal::DispatchTypes::GraphicsOptions> options,
+    size_t _SetRgbColorsHelper(const std::basic_string_view<::Microsoft::Console::VirtualTerminal::DispatchTypes::GraphicsOptions> options,
                                TextAttribute& attr,
                                const bool isForeground) noexcept;
 
-    bool _SetResetPrivateModes(const gsl::span<const ::Microsoft::Console::VirtualTerminal::DispatchTypes::PrivateModeParams> params, const bool enable) noexcept;
+    bool _SetResetPrivateModes(const std::basic_string_view<::Microsoft::Console::VirtualTerminal::DispatchTypes::PrivateModeParams> params, const bool enable) noexcept;
     bool _PrivateModeParamsHelper(const ::Microsoft::Console::VirtualTerminal::DispatchTypes::PrivateModeParams param, const bool enable) noexcept;
 };

src/cascadia/TerminalCore/TerminalDispatchGraphics.cpp

@@ -41,7 +41,7 @@ const BYTE BRIGHT_WHITE   = BRIGHT_ATTR | RED_ATTR | GREEN_ATTR | BLUE_ATTR;
 // - isForeground - Whether or not the parsed color is for the foreground.
 // Return Value:
 // - The number of options consumed, not including the initial 38/48.
-size_t TerminalDispatch::_SetRgbColorsHelper(const gsl::span<const DispatchTypes::GraphicsOptions> options,
+size_t TerminalDispatch::_SetRgbColorsHelper(const std::basic_string_view<DispatchTypes::GraphicsOptions> options,
                                              TextAttribute& attr,
                                              const bool isForeground) noexcept
 {
@@ -94,7 +94,7 @@ size_t TerminalDispatch::_SetRgbColorsHelper(const gsl::span<const DispatchTypes
 //   one at a time by setting or removing flags in the font style properties.
 // Return Value:
 // - True if handled successfully. False otherwise.
-bool TerminalDispatch::SetGraphicsRendition(const gsl::span<const DispatchTypes::GraphicsOptions> options) noexcept
+bool TerminalDispatch::SetGraphicsRendition(const std::basic_string_view<DispatchTypes::GraphicsOptions> options) noexcept
 {
     TextAttribute attr = _terminalApi.GetTextAttributes();
 
@@ -264,10 +264,10 @@ bool TerminalDispatch::SetGraphicsRendition(const gsl::span<const DispatchTypes:
             attr.SetIndexedBackground(BRIGHT_WHITE);
             break;
         case ForegroundExtended:
-            i += _SetRgbColorsHelper(options.subspan(i + 1), attr, true);
+            i += _SetRgbColorsHelper(options.substr(i + 1), attr, true);
             break;
         case BackgroundExtended:
-            i += _SetRgbColorsHelper(options.subspan(i + 1), attr, false);
+            i += _SetRgbColorsHelper(options.substr(i + 1), attr, false);
             break;
         }
     }

src/cascadia/UnitTests_TerminalCore/InputTest.cpp

@@ -30,7 +30,6 @@ namespace TerminalCoreUnitTests
 
         TEST_METHOD(AltShiftKey);
         TEST_METHOD(AltSpace);
-        TEST_METHOD(InvalidKeyEvent);
 
         void _VerifyExpectedInput(std::wstring& actualInput)
         {
@@ -66,14 +65,4 @@ namespace TerminalCoreUnitTests
         VERIFY_IS_FALSE(term.SendKeyEvent(L' ', 0, ControlKeyStates::LeftAltPressed, false));
         VERIFY_IS_FALSE(term.SendCharEvent(L' ', 0, ControlKeyStates::LeftAltPressed));
     }
-
-    void InputTest::InvalidKeyEvent()
-    {
-        // Certain applications like AutoHotKey and its keyboard remapping feature,
-        // send us key events using SendInput() whose values are outside of the valid range.
-        // We don't want to handle those events as we're probably going to get a proper followup character event.
-        VERIFY_IS_FALSE(term.SendKeyEvent(0, 123, {}, true));
-        VERIFY_IS_FALSE(term.SendKeyEvent(255, 123, {}, true));
-        VERIFY_IS_FALSE(term.SendKeyEvent(123, 0, {}, true));
-    }
 }

src/cascadia/WindowsTerminal/AppHost.cpp

@@ -17,10 +17,6 @@ using namespace winrt::Windows::Foundation::Numerics;
 using namespace ::Microsoft::Console;
 using namespace ::Microsoft::Console::Types;
 
-// This magic flag is "documented" at https://msdn.microsoft.com/en-us/library/windows/desktop/ms646301(v=vs.85).aspx
-// "If the high-order bit is 1, the key is down; otherwise, it is up."
-static constexpr short KeyPressed{ gsl::narrow_cast<short>(0x8000) };
-
 AppHost::AppHost() noexcept :
     _app{},
     _logic{ nullptr }, // don't make one, we're going to take a ref on app's
@@ -409,11 +405,7 @@ void AppHost::_WindowMouseWheeled(const til::point coord, const int32_t delta)
 
                     const til::point offsetPoint = coord - controlOrigin;
 
-                    const auto lButtonDown = WI_IsFlagSet(GetKeyState(VK_LBUTTON), KeyPressed);
-                    const auto mButtonDown = WI_IsFlagSet(GetKeyState(VK_MBUTTON), KeyPressed);
-                    const auto rButtonDown = WI_IsFlagSet(GetKeyState(VK_RBUTTON), KeyPressed);
-
-                    if (control.OnMouseWheel(offsetPoint, delta, lButtonDown, mButtonDown, rButtonDown))
+                    if (control.OnMouseWheel(offsetPoint, delta))
                     {
                         // If the element handled the mouse wheel event, don't
                         // continue to iterate over the remaining controls.

src/cascadia/WpfTerminalControl/NativeMethods.cs

@@ -62,16 +62,6 @@ namespace Microsoft.Terminal.Wpf
             /// </summary>
             WM_CHAR = 0x0102,
 
-            /// <summary>
-            /// The WM_SYSKEYDOWN message is posted to the window with the keyboard focus when a system key is pressed. A system key is F10 or Alt+Something.
-            /// </summary>
-            WM_SYSKEYDOWN = 0x0104,
-
-            /// <summary>
-            /// The WM_SYSKEYDOWN message is posted to the window with the keyboard focus when a system key is released. A system key is F10 or Alt+Something.
-            /// </summary>
-            WM_SYSKEYUP = 0x0105,
-
             /// <summary>
             /// The WM_MOUSEMOVE message is posted to a window when the cursor moves. If the mouse is not captured, the message is posted to the window that contains the cursor. Otherwise, the message is posted to the window that has captured the mouse.
             /// </summary>
@@ -225,10 +215,10 @@ namespace Microsoft.Terminal.Wpf
         public static extern void DestroyTerminal(IntPtr terminal);
 
         [DllImport("PublicTerminalCore.dll", CharSet = CharSet.Unicode, CallingConvention = CallingConvention.StdCall)]
-        public static extern void TerminalSendKeyEvent(IntPtr terminal, ushort vkey, ushort scanCode, ushort flags, bool keyDown);
+        public static extern void TerminalSendKeyEvent(IntPtr terminal, ushort vkey, ushort scanCode, bool keyDown);
 
         [DllImport("PublicTerminalCore.dll", CharSet = CharSet.Unicode, CallingConvention = CallingConvention.StdCall)]
-        public static extern void TerminalSendCharEvent(IntPtr terminal, char ch, ushort scanCode, ushort flags);
+        public static extern void TerminalSendCharEvent(IntPtr terminal, char ch, ushort scanCode);
 
         [DllImport("PublicTerminalCore.dll", CharSet = CharSet.Unicode, CallingConvention = CallingConvention.StdCall)]
         public static extern void TerminalSetTheme(IntPtr terminal, [MarshalAs(UnmanagedType.Struct)] TerminalTheme theme, string fontFamily, short fontSize, int newDpi);

src/cascadia/WpfTerminalControl/TerminalContainer.cs

@@ -20,20 +20,6 @@ namespace Microsoft.Terminal.Wpf
     /// </remarks>
     public class TerminalContainer : HwndHost
     {
-        private static void UnpackKeyMessage(IntPtr wParam, IntPtr lParam, out ushort vkey, out ushort scanCode, out ushort flags)
-        {
-            ulong scanCodeAndFlags = (((ulong)lParam) & 0xFFFF0000) >> 16;
-            scanCode = (ushort)(scanCodeAndFlags & 0x00FFu);
-            flags = (ushort)(scanCodeAndFlags & 0xFF00u);
-            vkey = (ushort)wParam;
-        }
-
-        private static void UnpackCharMessage(IntPtr wParam, IntPtr lParam, out char character, out ushort scanCode, out ushort flags)
-        {
-            UnpackKeyMessage(wParam, lParam, out ushort vKey, out scanCode, out flags);
-            character = (char)vKey;
-        }
-
         private ITerminalConnection connection;
         private IntPtr hwnd;
         private IntPtr terminal;
@@ -138,20 +124,6 @@ namespace Microsoft.Terminal.Wpf
             this.TriggerResize(this.RenderSize);
         }
 
-        /// <summary>
-        /// Gets the selected text from the terminal renderer and clears the selection.
-        /// </summary>
-        /// <returns>The selected text, empty if no text is selected.</returns>
-        internal string GetSelectedText()
-        {
-            if (NativeMethods.TerminalIsSelectionActive(this.terminal))
-            {
-                return NativeMethods.TerminalGetSelection(this.terminal);
-            }
-
-            return string.Empty;
-        }
-
         /// <summary>
         /// Triggers a refresh of the terminal with the given size.
         /// </summary>
@@ -263,35 +235,29 @@ namespace Microsoft.Terminal.Wpf
                         this.Focus();
                         NativeMethods.SetFocus(this.hwnd);
                         break;
-                    case NativeMethods.WindowMessage.WM_SYSKEYDOWN: // fallthrough
                     case NativeMethods.WindowMessage.WM_KEYDOWN:
                         {
                             // WM_KEYDOWN lParam layout documentation: https://docs.microsoft.com/en-us/windows/win32/inputdev/wm-keydown
                             NativeMethods.TerminalSetCursorVisible(this.terminal, true);
+                            ulong scanCode = (((ulong)lParam) & 0x00FF0000) >> 16;
 
-                            UnpackKeyMessage(wParam, lParam, out ushort vkey, out ushort scanCode, out ushort flags);
-                            NativeMethods.TerminalSendKeyEvent(this.terminal, vkey, scanCode, flags, true);
+                            NativeMethods.TerminalSendKeyEvent(this.terminal, (ushort)wParam, (ushort)scanCode, true);
                             this.blinkTimer?.Start();
                             break;
                         }
 
-                    case NativeMethods.WindowMessage.WM_SYSKEYUP: // fallthrough
                     case NativeMethods.WindowMessage.WM_KEYUP:
                         {
                             // WM_KEYUP lParam layout documentation: https://docs.microsoft.com/en-us/windows/win32/inputdev/wm-keyup
-                            UnpackKeyMessage(wParam, lParam, out ushort vkey, out ushort scanCode, out ushort flags);
-                            NativeMethods.TerminalSendKeyEvent(this.terminal, (ushort)wParam, scanCode, flags, false);
+                            ulong scanCode = (((ulong)lParam) & 0x00FF0000) >> 16;
+                            NativeMethods.TerminalSendKeyEvent(this.terminal, (ushort)wParam, (ushort)scanCode, false);
                             break;
                         }
 
                     case NativeMethods.WindowMessage.WM_CHAR:
-                        {
-                            // WM_CHAR lParam layout documentation: https://docs.microsoft.com/en-us/windows/win32/inputdev/wm-char
-                            UnpackCharMessage(wParam, lParam, out char character, out ushort scanCode, out ushort flags);
-                            NativeMethods.TerminalSendCharEvent(this.terminal, character, scanCode, flags);
-                            break;
-                        }
-
+                        // WM_CHAR lParam layout documentation: https://docs.microsoft.com/en-us/windows/win32/inputdev/wm-char
+                        NativeMethods.TerminalSendCharEvent(this.terminal, (char)wParam, (ushort)((uint)lParam >> 16));
+                        break;
                     case NativeMethods.WindowMessage.WM_WINDOWPOSCHANGED:
                         var windowpos = (NativeMethods.WINDOWPOS)Marshal.PtrToStructure(lParam, typeof(NativeMethods.WINDOWPOS));
                         if (((NativeMethods.SetWindowPosFlags)windowpos.flags).HasFlag(NativeMethods.SetWindowPosFlags.SWP_NOSIZE))

src/cascadia/WpfTerminalControl/TerminalControl.xaml.cs

@@ -70,15 +70,6 @@ namespace Microsoft.Terminal.Wpf
             this.termContainer.SetTheme(theme, fontFamily, fontSize);
         }
 
-        /// <summary>
-        /// Gets the selected text in the terminal, clearing the selection. Otherwise returns an empty string.
-        /// </summary>
-        /// <returns>Selected text, empty string if no content is selected.</returns>
-        public string GetSelectedText()
-        {
-            return this.termContainer.GetSelectedText();
-        }
-
         /// <summary>
         /// Resizes the terminal to the specified rows and columns.
         /// </summary>

src/cppwinrt.build.pre.props

@@ -22,20 +22,12 @@
        at the winmd we build to generate type info.
        In general, cppwinrt projects all want this.
   -->
-  <PropertyGroup Condition="'$(OpenConsoleUniversalApp)'=='true'">
+  <PropertyGroup Condition="'$(OpenConsoleUniversalApp)'!='false'">
     <MinimalCoreWin>true</MinimalCoreWin>
     <AppContainerApplication>true</AppContainerApplication>
     <WindowsStoreApp>true</WindowsStoreApp>
     <ApplicationType>Windows Store</ApplicationType>
   </PropertyGroup>
-  <PropertyGroup Condition="'$(OpenConsoleUniversalApp)'!='true'">
-    <!-- Some of our projects include the cppwinrt build options to
-         just build cppwinrt things, but don't want the store bits
-         in full swing. MinimalCoreWin != false means "don't let me
-         use win32 APIs"
-    -->
-    <MinimalCoreWin>false</MinimalCoreWin>
-  </PropertyGroup>
 
   <!-- This is magic that tells msbuild to link against the Desktop platform
        instead of the App platform. This you definitely want, because we're not

src/host/ApiRoutines.h

@@ -208,12 +208,12 @@ public:
                                                           size_t& written) noexcept override;
 
     [[nodiscard]] HRESULT WriteConsoleInputAImpl(InputBuffer& context,
-                                                 const gsl::span<const INPUT_RECORD> buffer,
+                                                 const std::basic_string_view<INPUT_RECORD> buffer,
                                                  size_t& written,
                                                  const bool append) noexcept override;
 
     [[nodiscard]] HRESULT WriteConsoleInputWImpl(InputBuffer& context,
-                                                 const gsl::span<const INPUT_RECORD> buffer,
+                                                 const std::basic_string_view<INPUT_RECORD> buffer,
                                                  size_t& written,
                                                  const bool append) noexcept override;
 
@@ -228,7 +228,7 @@ public:
                                                   Microsoft::Console::Types::Viewport& writtenRectangle) noexcept override;
 
     [[nodiscard]] HRESULT WriteConsoleOutputAttributeImpl(IConsoleOutputObject& OutContext,
-                                                          const gsl::span<const WORD> attrs,
+                                                          const std::basic_string_view<WORD> attrs,
                                                           const COORD target,
                                                           size_t& used) noexcept override;
 

src/host/_output.cpp

@@ -69,7 +69,7 @@ void WriteToScreen(SCREEN_INFORMATION& screenInfo, const Viewport& region)
 // Return Value:
 // - S_OK, E_INVALIDARG or similar HRESULT error.
 [[nodiscard]] HRESULT ApiRoutines::WriteConsoleOutputAttributeImpl(IConsoleOutputObject& OutContext,
-                                                                   const gsl::span<const WORD> attrs,
+                                                                   const std::basic_string_view<WORD> attrs,
                                                                    const COORD target,
                                                                    size_t& used) noexcept
 {

src/host/alias.cpp

@@ -149,7 +149,7 @@ std::unordered_map<std::wstring,
 
     if (target.has_value() && target->size() > 0)
     {
-        til::at(*target, 0) = UNICODE_NULL;
+        gsl::at(*target, 0) = UNICODE_NULL;
     }
 
     std::wstring exeNameString(exeName);
@@ -211,7 +211,7 @@ std::unordered_map<std::wstring,
     {
         if (target.size() > 0)
         {
-            til::at(target, 0) = ANSI_NULL;
+            gsl::at(target, 0) = ANSI_NULL;
         }
 
         LockConsole();
@@ -451,7 +451,7 @@ void Alias::s_ClearCmdExeAliases()
 
     if (aliasBuffer.has_value() && aliasBuffer->size() > 0)
     {
-        til::at(*aliasBuffer, 0) = UNICODE_NULL;
+        gsl::at(*aliasBuffer, 0) = UNICODE_NULL;
     }
 
     std::wstring exeNameString(exeName);
@@ -543,7 +543,7 @@ void Alias::s_ClearCmdExeAliases()
     {
         if (alias.size() > 0)
         {
-            til::at(alias, 0) = '\0';
+            gsl::at(alias, 0) = '\0';
         }
 
         LockConsole();
@@ -698,7 +698,7 @@ void Alias::s_ClearCmdExeAliases()
     writtenOrNeeded = 0;
     if (aliasExesBuffer.has_value() && aliasExesBuffer->size() > 0)
     {
-        til::at(*aliasExesBuffer, 0) = UNICODE_NULL;
+        gsl::at(*aliasExesBuffer, 0) = UNICODE_NULL;
     }
 
     LPWSTR AliasExesBufferPtrW = aliasExesBuffer.has_value() ? aliasExesBuffer->data() : nullptr;
@@ -761,7 +761,7 @@ void Alias::s_ClearCmdExeAliases()
     {
         if (aliasExes.size() > 0)
         {
-            til::at(aliasExes, 0) = '\0';
+            gsl::at(aliasExes, 0) = '\0';
         }
 
         LockConsole();

src/host/conareainfo.cpp

@@ -112,7 +112,7 @@ void ConversionAreaInfo::SetAttributes(const TextAttribute& attr)
 void ConversionAreaInfo::WriteText(const std::vector<OutputCell>& text,
                                    const SHORT column)
 {
-    gsl::span<const OutputCell> view(text.data(), text.size());
+    std::basic_string_view<OutputCell> view(text.data(), text.size());
     _screenBuffer->Write(view, { column, 0 });
 }
 

src/host/conimeinfo.cpp

@@ -57,15 +57,15 @@ void ConsoleImeInfo::RedrawCompMessage()
 // - attributes - Encoded attributes including the cursor position and the color index (to the array)
 // - colorArray - An array of colors to use for the text
 void ConsoleImeInfo::WriteCompMessage(const std::wstring_view text,
-                                      const gsl::span<const BYTE> attributes,
-                                      const gsl::span<const WORD> colorArray)
+                                      const std::basic_string_view<BYTE> attributes,
+                                      const std::basic_string_view<WORD> colorArray)
 {
     ClearAllAreas();
 
     // Save copies of the composition message in case we need to redraw it as things scroll/resize
     _text = text;
-    _attributes.assign(attributes.begin(), attributes.end());
-    _colorArray.assign(colorArray.begin(), colorArray.end());
+    _attributes = attributes;
+    _colorArray = colorArray;
 
     _WriteUndeterminedChars(text, attributes, colorArray);
 }
@@ -177,8 +177,8 @@ void ConsoleImeInfo::ClearAllAreas()
 // Return Value:
 // - TextAttribute object with color and cursor and line drawing data.
 TextAttribute ConsoleImeInfo::s_RetrieveAttributeAt(const size_t pos,
-                                                    const gsl::span<const BYTE> attributes,
-                                                    const gsl::span<const WORD> colorArray)
+                                                    const std::basic_string_view<BYTE> attributes,
+                                                    const std::basic_string_view<WORD> colorArray)
 {
     // Encoded attribute is the shorthand information passed from the IME
     // that contains a cursor position packed in along with which color in the
@@ -214,8 +214,8 @@ TextAttribute ConsoleImeInfo::s_RetrieveAttributeAt(const size_t pos,
 // Return Value:
 // - Vector of OutputCells where each one represents one cell of the output buffer.
 std::vector<OutputCell> ConsoleImeInfo::s_ConvertToCells(const std::wstring_view text,
-                                                         const gsl::span<const BYTE> attributes,
-                                                         const gsl::span<const WORD> colorArray)
+                                                         const std::basic_string_view<BYTE> attributes,
+                                                         const std::basic_string_view<WORD> colorArray)
 {
     std::vector<OutputCell> cells;
 
@@ -389,8 +389,8 @@ std::vector<OutputCell>::const_iterator ConsoleImeInfo::_WriteConversionArea(con
 //                each text character. This view must be the same size as the text view.
 // - colorArray - 8 colors to be used to format the text for display
 void ConsoleImeInfo::_WriteUndeterminedChars(const std::wstring_view text,
-                                             const gsl::span<const BYTE> attributes,
-                                             const gsl::span<const WORD> colorArray)
+                                             const std::basic_string_view<BYTE> attributes,
+                                             const std::basic_string_view<WORD> colorArray)
 {
     CONSOLE_INFORMATION& gci = ServiceLocator::LocateGlobals().getConsoleInformation();
     SCREEN_INFORMATION& screenInfo = gci.GetActiveOutputBuffer();

src/host/conimeinfo.h

@@ -48,8 +48,8 @@ public:
     [[nodiscard]] HRESULT ResizeAllAreas(const COORD newSize);
 
     void WriteCompMessage(const std::wstring_view text,
-                          const gsl::span<const BYTE> attributes,
-                          const gsl::span<const WORD> colorArray);
+                          const std::basic_string_view<BYTE> attributes,
+                          const std::basic_string_view<WORD> colorArray);
 
     void WriteResultMessage(const std::wstring_view text);
 
@@ -64,18 +64,18 @@ private:
     void _ClearComposition();
 
     void _WriteUndeterminedChars(const std::wstring_view text,
-                                 const gsl::span<const BYTE> attributes,
-                                 const gsl::span<const WORD> colorArray);
+                                 const std::basic_string_view<BYTE> attributes,
+                                 const std::basic_string_view<WORD> colorArray);
 
     void _InsertConvertedString(const std::wstring_view text);
 
     static TextAttribute s_RetrieveAttributeAt(const size_t pos,
-                                               const gsl::span<const BYTE> attributes,
-                                               const gsl::span<const WORD> colorArray);
+                                               const std::basic_string_view<BYTE> attributes,
+                                               const std::basic_string_view<WORD> colorArray);
 
     static std::vector<OutputCell> s_ConvertToCells(const std::wstring_view text,
-                                                    const gsl::span<const BYTE> attributes,
-                                                    const gsl::span<const WORD> colorArray);
+                                                    const std::basic_string_view<BYTE> attributes,
+                                                    const std::basic_string_view<WORD> colorArray);
 
     std::vector<OutputCell>::const_iterator _WriteConversionArea(const std::vector<OutputCell>::const_iterator begin,
                                                                  const std::vector<OutputCell>::const_iterator end,
@@ -86,6 +86,6 @@ private:
     bool _isSavedCursorVisible;
 
     std::wstring _text;
-    std::vector<BYTE> _attributes;
-    std::vector<WORD> _colorArray;
+    std::basic_string<BYTE> _attributes;
+    std::basic_string<WORD> _colorArray;
 };

src/host/convarea.cpp

@@ -125,8 +125,8 @@ void WriteConvRegionToScreen(const SCREEN_INFORMATION& ScreenInfo,
 }
 
 [[nodiscard]] HRESULT ImeComposeData(std::wstring_view text,
-                                     gsl::span<const BYTE> attributes,
-                                     gsl::span<const WORD> colorArray)
+                                     std::basic_string_view<BYTE> attributes,
+                                     std::basic_string_view<WORD> colorArray)
 {
     try
     {

src/host/dbcs.cpp

@@ -67,10 +67,10 @@ DWORD UnicodeRasterFontCellMungeOnRead(const gsl::span<CHAR_INFO> buffer)
     for (DWORD iSrc = 0; iSrc < buffer.size(); iSrc++)
     {
         // If it's not a trailing byte, copy it straight over, stripping out the Leading/Trailing flags from the attributes field.
-        auto& src{ til::at(buffer, iSrc) };
+        auto& src{ gsl::at(buffer, iSrc) };
         if (!WI_IsFlagSet(src.Attributes, COMMON_LVB_TRAILING_BYTE))
         {
-            auto& dst{ til::at(buffer, iDst) };
+            auto& dst{ gsl::at(buffer, iDst) };
             dst = src;
             WI_ClearAllFlags(dst.Attributes, COMMON_LVB_SBCSDBCS);
             iDst++;

src/host/directio.cpp

@@ -472,7 +472,7 @@ void EventsToUnicode(_Inout_ std::deque<std::unique_ptr<IInputEvent>>& inEvents,
 // Return Value:
 // - HRESULT indicating success or failure
 [[nodiscard]] HRESULT ApiRoutines::WriteConsoleInputAImpl(InputBuffer& context,
-                                                          const gsl::span<const INPUT_RECORD> buffer,
+                                                          const std::basic_string_view<INPUT_RECORD> buffer,
                                                           size_t& written,
                                                           const bool append) noexcept
 {
@@ -516,7 +516,7 @@ void EventsToUnicode(_Inout_ std::deque<std::unique_ptr<IInputEvent>>& inEvents,
 // Return Value:
 // - HRESULT indicating success or failure
 [[nodiscard]] HRESULT ApiRoutines::WriteConsoleInputWImpl(InputBuffer& context,
-                                                          const gsl::span<const INPUT_RECORD> buffer,
+                                                          const std::basic_string_view<INPUT_RECORD> buffer,
                                                           size_t& written,
                                                           const bool append) noexcept
 {
@@ -1042,7 +1042,7 @@ void EventsToUnicode(_Inout_ std::deque<std::unique_ptr<IInputEvent>>& inEvents,
             const auto subspan = buffer.subspan(totalOffset, writeRectangle.Width());
 
             // Convert to a CHAR_INFO view to fit into the iterator
-            const auto charInfos = gsl::span<const CHAR_INFO>(subspan.data(), subspan.size());
+            const auto charInfos = std::basic_string_view<CHAR_INFO>(subspan.data(), subspan.size());
 
             // Make the iterator and write to the target position.
             OutputCellIterator it(charInfos);

src/host/getset.cpp

@@ -1604,7 +1604,7 @@ void DoSrvPrivateRefreshWindow(_In_ const SCREEN_INFORMATION& screenInfo)
 
         if (title.has_value() && title->size() > 0)
         {
-            til::at(*title, 0) = ANSI_NULL;
+            gsl::at(*title, 0) = ANSI_NULL;
         }
 
         // Get the appropriate title and length depending on the mode.
@@ -1667,7 +1667,7 @@ void DoSrvPrivateRefreshWindow(_In_ const SCREEN_INFORMATION& screenInfo)
 
         if (title.size() > 0)
         {
-            til::at(title, 0) = ANSI_NULL;
+            gsl::at(title, 0) = ANSI_NULL;
         }
 
         // Figure out how big our temporary Unicode buffer must be to get the title.
@@ -1722,7 +1722,7 @@ void DoSrvPrivateRefreshWindow(_In_ const SCREEN_INFORMATION& screenInfo)
             // If we didn't copy anything back and there is space, null terminate the given buffer and return.
             if (title.size() > 0)
             {
-                til::at(title, 0) = ANSI_NULL;
+                gsl::at(title, 0) = ANSI_NULL;
                 written = 1;
             }
         }

src/host/history.cpp

@@ -782,7 +782,7 @@ HRESULT GetConsoleCommandHistoryWImplHelper(const std::wstring_view exeName,
     writtenOrNeeded = 0;
     if (historyBuffer.size() > 0)
     {
-        til::at(historyBuffer, 0) = UNICODE_NULL;
+        gsl::at(historyBuffer, 0) = UNICODE_NULL;
     }
 
     CommandHistory* const CommandHistory = CommandHistory::s_FindByExe(exeName);
@@ -859,7 +859,7 @@ HRESULT ApiRoutines::GetConsoleCommandHistoryAImpl(const std::string_view exeNam
     {
         if (commandHistory.size() > 0)
         {
-            til::at(commandHistory, 0) = ANSI_NULL;
+            gsl::at(commandHistory, 0) = ANSI_NULL;
         }
 
         LockConsole();

src/host/settings.cpp

@@ -726,12 +726,12 @@ void Settings::SetHistoryNoDup(const bool bHistoryNoDup)
     _bHistoryNoDup = bHistoryNoDup;
 }
 
-gsl::span<const COLORREF> Settings::Get16ColorTable() const
+std::basic_string_view<COLORREF> Settings::Get16ColorTable() const
 {
-    return Get256ColorTable().subspan(0, 16);
+    return Get256ColorTable().substr(0, 16);
 }
 
-gsl::span<const COLORREF> Settings::Get256ColorTable() const
+std::basic_string_view<COLORREF> Settings::Get256ColorTable() const
 {
     return { _colorTable.data(), _colorTable.size() };
 }

src/host/settings.hpp

@@ -159,8 +159,8 @@ public:
     bool GetHistoryNoDup() const;
     void SetHistoryNoDup(const bool fHistoryNoDup);
 
-    gsl::span<const COLORREF> Get16ColorTable() const;
-    gsl::span<const COLORREF> Get256ColorTable() const;
+    std::basic_string_view<COLORREF> Get16ColorTable() const;
+    std::basic_string_view<COLORREF> Get256ColorTable() const;
     void SetColorTableEntry(const size_t index, const COLORREF ColorValue);
     COLORREF GetColorTableEntry(const size_t index) const;
 

src/host/ut_host/OutputCellIteratorTests.cpp

@@ -367,7 +367,7 @@ class OutputCellIteratorTests
         SetVerifyOutput settings(VerifyOutputSettings::LogOnlyFailures);
 
         const std::vector<WORD> colors{ FOREGROUND_GREEN, FOREGROUND_RED | BACKGROUND_BLUE, FOREGROUND_BLUE | FOREGROUND_INTENSITY, BACKGROUND_GREEN };
-        const gsl::span<const WORD> view{ colors.data(), colors.size() };
+        const std::basic_string_view<WORD> view{ colors.data(), colors.size() };
 
         OutputCellIterator it(view);
 
@@ -401,7 +401,7 @@ class OutputCellIteratorTests
             charInfos.push_back(ci);
         }
 
-        const gsl::span<const CHAR_INFO> view{ charInfos.data(), charInfos.size() };
+        const std::basic_string_view<CHAR_INFO> view{ charInfos.data(), charInfos.size() };
 
         OutputCellIterator it(view);
 
@@ -433,7 +433,7 @@ class OutputCellIteratorTests
             cells.push_back(cell);
         }
 
-        const gsl::span<const OutputCell> view{ cells.data(), cells.size() };
+        const std::basic_string_view<OutputCell> view{ cells.data(), cells.size() };
 
         OutputCellIterator it(view);
 

src/host/ut_host/VtIoTests.cpp

@@ -254,145 +254,6 @@ void VtIoTests::DtorTestStackAllocMany()
     }
 }
 
-class MockRenderData : public IRenderData, IUiaData
-{
-public:
-    Microsoft::Console::Types::Viewport GetViewport() noexcept override
-    {
-        return Microsoft::Console::Types::Viewport{};
-    }
-
-    COORD GetTextBufferEndPosition() const noexcept override
-    {
-        return COORD{};
-    }
-
-    const TextBuffer& GetTextBuffer() noexcept override
-    {
-        FAIL_FAST_HR(E_NOTIMPL);
-    }
-
-    const FontInfo& GetFontInfo() noexcept override
-    {
-        FAIL_FAST_HR(E_NOTIMPL);
-    }
-
-    std::vector<Microsoft::Console::Types::Viewport> GetSelectionRects() noexcept override
-    {
-        return std::vector<Microsoft::Console::Types::Viewport>{};
-    }
-
-    void LockConsole() noexcept override
-    {
-    }
-
-    void UnlockConsole() noexcept override
-    {
-    }
-
-    const TextAttribute GetDefaultBrushColors() noexcept override
-    {
-        return TextAttribute{};
-    }
-
-    std::pair<COLORREF, COLORREF> GetAttributeColors(const TextAttribute& /*attr*/) const noexcept override
-    {
-        return std::make_pair(COLORREF{}, COLORREF{});
-    }
-
-    COORD GetCursorPosition() const noexcept override
-    {
-        return COORD{};
-    }
-
-    bool IsCursorVisible() const noexcept override
-    {
-        return false;
-    }
-
-    bool IsCursorOn() const noexcept override
-    {
-        return false;
-    }
-
-    ULONG GetCursorHeight() const noexcept override
-    {
-        return 42ul;
-    }
-
-    CursorType GetCursorStyle() const noexcept override
-    {
-        return CursorType::FullBox;
-    }
-
-    ULONG GetCursorPixelWidth() const noexcept override
-    {
-        return 12ul;
-    }
-
-    COLORREF GetCursorColor() const noexcept override
-    {
-        return COLORREF{};
-    }
-
-    bool IsCursorDoubleWidth() const override
-    {
-        return false;
-    }
-
-    bool IsScreenReversed() const noexcept override
-    {
-        return false;
-    }
-
-    const std::vector<RenderOverlay> GetOverlays() const noexcept override
-    {
-        return std::vector<RenderOverlay>{};
-    }
-
-    const bool IsGridLineDrawingAllowed() noexcept override
-    {
-        return false;
-    }
-
-    const std::wstring GetConsoleTitle() const noexcept override
-    {
-        return std::wstring{};
-    }
-
-    const bool IsSelectionActive() const override
-    {
-        return false;
-    }
-
-    const bool IsBlockSelection() const noexcept override
-    {
-        return false;
-    }
-
-    void ClearSelection() override
-    {
-    }
-
-    void SelectNewRegion(const COORD /*coordStart*/, const COORD /*coordEnd*/) override
-    {
-    }
-
-    const COORD GetSelectionAnchor() const noexcept
-    {
-        return COORD{};
-    }
-
-    const COORD GetSelectionEnd() const noexcept
-    {
-        return COORD{};
-    }
-
-    void ColorSelection(const COORD /*coordSelectionStart*/, const COORD /*coordSelectionEnd*/, const TextAttribute /*attr*/)
-    {
-    }
-};
-
 void VtIoTests::RendererDtorAndThread()
 {
     Log::Comment(NoThrowString().Format(
@@ -400,10 +261,9 @@ void VtIoTests::RendererDtorAndThread()
 
     for (int i = 0; i < 16; ++i)
     {
-        auto data = std::make_unique<MockRenderData>();
         auto thread = std::make_unique<Microsoft::Console::Render::RenderThread>();
         auto* pThread = thread.get();
-        auto pRenderer = std::make_unique<Microsoft::Console::Render::Renderer>(data.get(), nullptr, 0, std::move(thread));
+        auto pRenderer = std::make_unique<Microsoft::Console::Render::Renderer>(nullptr, nullptr, 0, std::move(thread));
         VERIFY_SUCCEEDED(pThread->Initialize(pRenderer.get()));
         // Sleep for a hot sec to make sure the thread starts before we enable painting
         // If you don't, the thread might wait on the paint enabled event AFTER
@@ -426,10 +286,9 @@ void VtIoTests::RendererDtorAndThreadAndDx()
 
     for (int i = 0; i < 16; ++i)
     {
-        auto data = std::make_unique<MockRenderData>();
         auto thread = std::make_unique<Microsoft::Console::Render::RenderThread>();
         auto* pThread = thread.get();
-        auto pRenderer = std::make_unique<Microsoft::Console::Render::Renderer>(data.get(), nullptr, 0, std::move(thread));
+        auto pRenderer = std::make_unique<Microsoft::Console::Render::Renderer>(nullptr, nullptr, 0, std::move(thread));
         VERIFY_SUCCEEDED(pThread->Initialize(pRenderer.get()));
 
         auto dxEngine = std::make_unique<::Microsoft::Console::Render::DxEngine>();

src/inc/conime.h

@@ -32,8 +32,8 @@ constexpr BYTE CONIME_CURSOR_LEFT = 0x20;
 [[nodiscard]] HRESULT ImeEndComposition();
 
 [[nodiscard]] HRESULT ImeComposeData(std::wstring_view text,
-                                     gsl::span<const BYTE> attributes,
-                                     gsl::span<const WORD> colorArray);
+                                     std::basic_string_view<BYTE> attributes,
+                                     std::basic_string_view<WORD> colorArray);
 
 [[nodiscard]] HRESULT ImeClearComposeData();
 

src/inc/til.h

@@ -15,7 +15,6 @@
 #include "til/rectangle.h"
 #include "til/bitmap.h"
 #include "til/u8u16convert.h"
-#include "til/spsc.h"
 
 namespace til // Terminal Implementation Library. Also: "Today I Learned"
 {

src/inc/til/at.h

@@ -5,52 +5,17 @@
 
 namespace til
 {
-    namespace details
-    {
-        // This was lifted from gsl::details::is_span.
-        template<class T>
-        struct is_span_oracle : std::false_type
-        {
-        };
-
-#ifdef GSL_SPAN_H
-        template<class ElementType, std::size_t Extent>
-        struct is_span_oracle<gsl::span<ElementType, Extent>> : std::true_type
-        {
-        };
-#endif
-
-        template<class T>
-        struct is_span : public is_span_oracle<std::remove_cv_t<T>>
-        {
-        };
-    }
-
     // The at function declares that you've already sufficiently checked that your array access
     // is in range before retrieving an item inside it at an offset.
     // This is to save double/triple/quadruple testing in circumstances where you are already
     // pivoting on the length of a set and now want to pull elements out of it by offset
     // without checking again.
     // gsl::at will do the check again. As will .at(). And using [] will have a warning in audit.
-    // This template is explicitly disabled if T is of type gsl::span, as it would interfere with
-    // the overload below.
-    template<class T, std::enable_if_t<!details::is_span<T>::value, int> = 0>
+    template<class T>
     constexpr auto at(T& cont, const size_t i) -> decltype(cont[cont.size()])
     {
 #pragma warning(suppress : 26482) // Suppress bounds.2 check for indexing with constant expressions
 #pragma warning(suppress : 26446) // Suppress bounds.4 check for subscript operator.
         return cont[i];
     }
-
-#ifdef GSL_SPAN_H
-    // This is an overload of til::at for span that access its backing buffer directly (UNCHECKED)
-    template<typename ElementType, size_t Extent>
-    constexpr auto at(gsl::span<ElementType, Extent> span, const std::ptrdiff_t i) -> decltype(span[span.size()])
-    {
-#pragma warning(suppress : 26481) // Suppress bounds.1 check for doing pointer arithmetic
-#pragma warning(suppress : 26482) // Suppress bounds.2 check for indexing with constant expressions
-#pragma warning(suppress : 26446) // Suppress bounds.4 check for subscript operator.
-        return span.data()[i];
-    }
-#endif
 }

src/inc/til/spsc.h

@@ -1,643 +0,0 @@
-// Copyright (c) Microsoft Corporation.
-// Licensed under the MIT license.
-
-#pragma once
-
-// til::spsc::details::arc requires std::atomic<size_type>::wait() and ::notify_one() and at the time of writing no
-// STL supports these. Since both Windows and Linux offer a Futex implementation we can easily implement this though.
-// On other platforms we fall back to using a std::condition_variable.
-#if __cpp_lib_atomic_wait >= 201907
-#define _TIL_SPSC_DETAIL_POSITION_IMPL_NATIVE 1
-#elif defined(_WIN32_WINNT) && _WIN32_WINNT >= _WIN32_WINNT_WIN8
-#define _TIL_SPSC_DETAIL_POSITION_IMPL_WIN 1
-#elif __linux__
-#define _TIL_SPSC_DETAIL_POSITION_IMPL_LINUX 1
-#else
-#define _TIL_SPSC_DETAIL_POSITION_IMPL_FALLBACK 1
-#endif
-
-// til: Terminal Implementation Library. Also: "Today I Learned".
-// spsc: Single Producer Single Consumer. A SPSC queue/channel sends data from exactly one sender to one receiver.
-namespace til::spsc
-{
-    using size_type = uint32_t;
-
-    namespace details
-    {
-        static constexpr size_type position_mask = std::numeric_limits<size_type>::max() >> 2u; // 0b00111....
-        static constexpr size_type revolution_flag = 1u << (std::numeric_limits<size_type>::digits - 2u); // 0b01000....
-        static constexpr size_type drop_flag = 1u << (std::numeric_limits<size_type>::digits - 1u); // 0b10000....
-
-        struct block_initially_policy
-        {
-            using _spsc_policy = int;
-            static constexpr bool _block_forever = false;
-        };
-
-        struct block_forever_policy
-        {
-            using _spsc_policy = int;
-            static constexpr bool _block_forever = true;
-        };
-
-        template<typename WaitPolicy>
-        using enable_if_wait_policy_t = typename std::remove_reference_t<WaitPolicy>::_spsc_policy;
-
-#if _TIL_SPSC_DETAIL_POSITION_IMPL_NATIVE
-        using atomic_size_type = std::atomic<size_type>;
-#else
-        // atomic_size_type is a fallback if native std::atomic<size_type>::wait()
-        // and ::notify_one() methods are unavailable in the STL.
-        struct atomic_size_type
-        {
-            size_type load(std::memory_order order) const noexcept
-            {
-                return _value.load(order);
-            }
-
-            void store(size_type desired, std::memory_order order) noexcept
-            {
-#if _TIL_SPSC_DETAIL_POSITION_IMPL_FALLBACK
-                // We must use a lock here to prevent us from modifying the value
-                // in between wait() reading the value and the thread being suspended.
-                std::lock_guard<std::mutex> lock{ _m };
-#endif
-                _value.store(desired, order);
-            }
-
-            void wait(size_type old, [[maybe_unused]] std::memory_order order) const noexcept
-            {
-#if _TIL_SPSC_DETAIL_POSITION_IMPL_WIN
-#pragma warning(suppress : 26492) // Don't use const_cast to cast away const or volatile
-                WaitOnAddress(const_cast<std::atomic<size_type>*>(&_value), &old, sizeof(_value), INFINITE);
-#elif _TIL_SPSC_DETAIL_POSITION_IMPL_LINUX
-                futex(FUTEX_WAIT_PRIVATE, old);
-#elif _TIL_SPSC_DETAIL_POSITION_IMPL_FALLBACK
-                std::unique_lock<std::mutex> lock{ _m };
-                _cv.wait(lock, [&]() { return _value.load(order) != old; });
-#endif
-            }
-
-            void notify_one() noexcept
-            {
-#if _TIL_SPSC_DETAIL_POSITION_IMPL_WIN
-                WakeByAddressSingle(&_value);
-#elif _TIL_SPSC_DETAIL_POSITION_IMPL_LINUX
-                futex(FUTEX_WAKE_PRIVATE, 1);
-#elif _TIL_SPSC_DETAIL_POSITION_IMPL_FALLBACK
-                _cv.notify_one();
-#endif
-            }
-
-        private:
-#if _TIL_SPSC_DETAIL_POSITION_IMPL_LINUX
-            inline void futex(int futex_op, size_type val) const noexcept
-            {
-                // See: https://man7.org/linux/man-pages/man2/futex.2.html
-                static_assert(sizeof(std::atomic<size_type>) == 4);
-                syscall(SYS_futex, &_value, futex_op, val, nullptr, nullptr, 0);
-            }
-#endif
-
-            std::atomic<size_type> _value{ 0 };
-
-#if _TIL_SPSC_DETAIL_POSITION_IMPL_FALLBACK
-        private:
-            std::mutex _m;
-            std::condition_variable _cv;
-#endif
-        };
-#endif
-
-        template<typename T>
-        inline T* alloc_raw_memory(size_t size)
-        {
-            constexpr auto alignment = alignof(T);
-            if constexpr (alignment <= __STDCPP_DEFAULT_NEW_ALIGNMENT__)
-            {
-                return static_cast<T*>(::operator new(size));
-            }
-            else
-            {
-                return static_cast<T*>(::operator new(size, std::align_val_t(alignment)));
-            }
-        }
-
-        template<typename T>
-        inline void free_raw_memory(T* ptr) noexcept
-        {
-            constexpr auto alignment = alignof(T);
-            if constexpr (alignment <= __STDCPP_DEFAULT_NEW_ALIGNMENT__)
-            {
-                ::operator delete(ptr);
-            }
-            else
-            {
-                ::operator delete(ptr, std::align_val_t(alignment));
-            }
-        }
-
-        struct acquisition
-        {
-            // The index range [begin, end) is the range of slots in the array returned by
-            // arc<T>::data() that may be written to / read from respectively.
-            // If a range has been successfully acquired "end > begin" is true. end thus can't be 0.
-            size_type begin;
-            size_type end;
-
-            // Upon release() of an acquisition, next is the value that's written to the consumer/producer position.
-            // It's basically the same as end, but with the revolution flag mixed in.
-            // If end is equal to capacity, next will be 0 (mixed with the next revolution flag).
-            size_type next;
-
-            // If the other side of the queue hasn't been destroyed yet, alive will be true.
-            bool alive;
-
-            constexpr acquisition(size_type begin, size_type end, size_type next, bool alive) :
-                begin(begin),
-                end(end),
-                next(next),
-                alive(alive)
-            {
-            }
-        };
-
-        // The following assumes you know what ring/circular buffers are. You can read about them here:
-        //   https://en.wikipedia.org/wiki/Circular_buffer
-        //
-        // Furthermore the implementation solves a problem known as the producer-consumer problem:
-        //   https://en.wikipedia.org/wiki/Producer%E2%80%93consumer_problem
-        //
-        // arc follows the classic spsc design and manages a ring buffer with two positions: _producer and _consumer.
-        // They contain the position the producer / consumer will next write to / read from respectively.
-        // As usual with ring buffers, these positions are modulo to the _capacity of the underlying buffer.
-        // The producer's writable range is [_producer, _consumer) and the consumer's readable is [_consumer, _producer).
-        //
-        // After you wrote the numbers 0 to 6 into a queue of size 10, a typical state of the ring buffer might be:
-        //   [ 0 | 1 | 2 | 3 | 4 | 5 | 6 | _ | _ | _ | _ ]
-        //     ^                           ^             ^
-        // _consumer = 0            _producer = 7    _capacity = 10
-        //
-        // As you can see the readable range currently is [_consumer, _producer) = [0, 7).
-        // The remaining writable range on the other hand is [_producer, _consumer) = [7, 0).
-        // Wait, what? [7, 0)? How does that work? As all positions are modulo _capacity, 0 mod 10 is the same as 10 mod 10.
-        // If we only want to read forward in the buffer [7, 0) is thus the same as [7, 10).
-        //
-        // If we read 3 items from the queue the contents will be:
-        //   [ _ | _ | _ | 3 | 4 | 5 | 6 | _ | _ | _ | _ ]
-        //                 ^               ^
-        //          _consumer = 3      _producer = 7
-        //
-        // Now the writable range is still [_producer, _consumer), but it wraps around the end of the ring buffer.
-        // In this case arc will split the range in two and return each separately in acquire().
-        // The first returned range will be [_producer, _capacity) and the second [0, _consumer).
-        // The same logic applies if the readable range wraps around the end of the ring buffer.
-        //
-        // As these are symmetric, the logic for acquiring and releasing ranges is the same for both sides.
-        // The producer will acquire() and release() ranges with its own position as "mine" and the consumer's
-        // position as "theirs". These arguments are correspondingly flipped for the consumer.
-        //
-        // As part of the producer-consumer problem, the producer cannot write more values ahead of the
-        // consumer than the buffer's capacity. Since both positions are modulo to the capacity we can only
-        // determine positional differences smaller than the capacity. Due to that both producer and
-        // consumer store a "revolution_flag" as the second highest bit within their positions.
-        // This bit is flipped each time the producer/consumer wrap around the end of the ring buffer.
-        // If the positions are identical, except for their "revolution_flag" value, the producer thus must
-        // be capacity-many positions ahead of the consumer and must wait until items have been consumed.
-        //
-        // Inversely the consumer must wait until the producer has written at least one value ahead.
-        // This can be detected by checking whether the positions are identical including the revolution_flag.
-        template<typename T>
-        struct arc
-        {
-            explicit arc(size_type capacity) noexcept :
-                _data(alloc_raw_memory<T>(size_t(capacity) * sizeof(T))),
-                _capacity(capacity)
-            {
-            }
-
-            ~arc()
-            {
-                auto beg = _consumer.load(std::memory_order_acquire);
-                auto end = _producer.load(std::memory_order_acquire);
-                auto differentRevolution = ((beg ^ end) & revolution_flag) != 0;
-
-                beg &= position_mask;
-                end &= position_mask;
-
-                // The producer position will always be ahead of the consumer, but since we're dealing
-                // with a ring buffer the producer may be wrapped around the end of the buffer.
-                // We thus need to deal with 3 potential cases:
-                // * No valid data.
-                //   If both positions including their revolution bits are identical.
-                // * Valid data in the middle of the ring buffer.
-                //   If _producer > _consumer.
-                // * Valid data at both ends of the ring buffer.
-                //   If the revolution bits differ, even if the positions are otherwise identical,
-                //   which they might be if the channel contains exactly as many values as its capacity.
-                if (end > beg)
-                {
-                    std::destroy(_data + beg, _data + end);
-                }
-                else if (differentRevolution)
-                {
-                    std::destroy(_data, _data + end);
-                    std::destroy(_data + beg, _data + _capacity);
-                }
-
-                free_raw_memory(_data);
-            }
-
-            void drop_producer()
-            {
-                drop(_producer);
-            }
-
-            void drop_consumer()
-            {
-                drop(_consumer);
-            }
-
-            acquisition producer_acquire(size_type slots, bool blocking) noexcept
-            {
-                return acquire(_producer, _consumer, revolution_flag, slots, blocking);
-            }
-
-            void producer_release(acquisition acquisition) noexcept
-            {
-                release(_producer, acquisition);
-            }
-
-            acquisition consumer_acquire(size_type slots, bool blocking) noexcept
-            {
-                return acquire(_consumer, _producer, 0, slots, blocking);
-            }
-
-            void consumer_release(acquisition acquisition) noexcept
-            {
-                release(_consumer, acquisition);
-            }
-
-            T* data() const noexcept
-            {
-                return _data;
-            }
-
-        private:
-            void drop(atomic_size_type& mine)
-            {
-                // Signal the other side we're dropped. See acquire() for the handling of the drop_flag.
-                // We don't need to use release ordering like release() does as each call to
-                // any of the producer/consumer methods already results in a call to release().
-                // Another release ordered write can't possibly synchronize any more data anyways at this point.
-                const auto myPos = mine.load(std::memory_order_relaxed);
-                mine.store(myPos | drop_flag, std::memory_order_relaxed);
-                mine.notify_one();
-
-                // The first time SPSCBase is dropped (destroyed) we'll set
-                // the flag to true and get false, causing us to return early.
-                // Only the second time we'll get true.
-                // --> The contents are only deleted when both sides have been dropped.
-                if (_eitherSideDropped.exchange(true, std::memory_order_relaxed))
-                {
-                    delete this;
-                }
-            }
-
-            // NOTE: waitMask MUST be either 0 (consumer) or revolution_flag (producer).
-            acquisition acquire(atomic_size_type& mine, atomic_size_type& theirs, size_type waitMask, size_type slots, bool blocking) noexcept
-            {
-                size_type myPos = mine.load(std::memory_order_relaxed);
-                size_type theirPos;
-
-                while (true)
-                {
-                    // This acquire read synchronizes with the release write in release().
-                    theirPos = theirs.load(std::memory_order_acquire);
-                    if ((myPos ^ theirPos) != waitMask)
-                    {
-                        break;
-                    }
-                    if (!blocking)
-                    {
-                        return {
-                            0,
-                            0,
-                            0,
-                            true,
-                        };
-                    }
-
-                    theirs.wait(theirPos, std::memory_order_relaxed);
-                }
-
-                // If the other side's position contains a drop flag, as a X -> we need to...
-                // * producer -> stop immediately
-                //   FYI: isProducer == (waitMask != 0).
-                // * consumer -> finish consuming all values and then stop
-                //   We're finished if the only difference between our
-                //   and the other side's position is the drop flag.
-                if ((theirPos & drop_flag) != 0 && (waitMask != 0 || (myPos ^ theirPos) == drop_flag))
-                {
-                    return {
-                        0,
-                        0,
-                        0,
-                        false,
-                    };
-                }
-
-                auto begin = myPos & position_mask;
-                auto end = theirPos & position_mask;
-
-                // [begin, end) is the writable/readable range for the producer/consumer.
-                // The following detects whether we'd be wrapping around the end of the ring buffer
-                // and splits the range into the first half [mine, _capacity).
-                // If acquire() is called again it'll return [0, theirs).
-                end = end > begin ? end : _capacity;
-
-                // Of course we also need to ensure to not return more than we've been asked for.
-                end = std::min(end, begin + slots);
-
-                // "next" will contain the value that's stored into "mine" when release() is called.
-                // It's basically the same as "end", but with the revolution flag spliced in.
-                // If we acquired the range [mine, _capacity) "end" will equal _capacity
-                // and thus wrap around the ring buffer. The next value for "mine" is thus the
-                // position zero | the flipped "revolution" (and 0 | x == x).
-                auto revolution = myPos & revolution_flag;
-                auto next = end != _capacity ? end | revolution : revolution ^ revolution_flag;
-
-                return {
-                    begin,
-                    end,
-                    next,
-                    true,
-                };
-            }
-
-            void release(atomic_size_type& mine, acquisition acquisition) noexcept
-            {
-                // This release write synchronizes with the acquire read in acquire().
-                mine.store(acquisition.next, std::memory_order_release);
-                mine.notify_one();
-            }
-
-            T* const _data;
-            const size_type _capacity;
-
-            std::atomic<bool> _eitherSideDropped{ false };
-
-            atomic_size_type _producer;
-            atomic_size_type _consumer;
-        };
-
-        inline void validate_size(size_t v)
-        {
-            if (v > static_cast<size_t>(position_mask))
-            {
-                throw std::overflow_error{ "size too large for spsc" };
-            }
-        }
-    }
-
-    // Block until at least one item has been written into the sender / read from the receiver.
-    inline constexpr details::block_initially_policy block_initially{};
-
-    // Block until all items have been written into the sender / read from the receiver.
-    inline constexpr details::block_forever_policy block_forever{};
-
-    template<typename T>
-    struct producer
-    {
-        explicit producer(details::arc<T>* arc) noexcept :
-            _arc(arc) {}
-
-        producer<T>(const producer<T>&) = delete;
-        producer<T>& operator=(const producer<T>&) = delete;
-
-        producer(producer<T>&& other) noexcept
-        {
-            drop();
-            _arc = std::exchange(other._arc, nullptr);
-        }
-
-        producer<T>& operator=(producer<T>&& other) noexcept
-        {
-            drop();
-            _arc = std::exchange(other._arc, nullptr);
-        }
-
-        ~producer()
-        {
-            drop();
-        }
-
-        // emplace constructs an item in-place at the end of the queue.
-        // It returns true, if the item was successfully placed within the queue.
-        // The return value will be false, if the consumer is gone.
-        template<typename... Args>
-        bool emplace(Args&&... args) const
-        {
-            auto acquisition = _arc->producer_acquire(1, true);
-            if (!acquisition.end)
-            {
-                return false;
-            }
-
-            auto data = _arc->data();
-            auto begin = data + acquisition.begin;
-            new (begin) T(std::forward<Args>(args)...);
-
-            _arc->producer_release(acquisition);
-            return true;
-        }
-
-        template<typename InputIt>
-        std::pair<size_t, bool> push(InputIt first, InputIt last) const
-        {
-            return push_n(block_forever, first, std::distance(first, last));
-        }
-
-        // push writes the items between first and last into the queue.
-        // The amount of successfully written items is returned as the first pair field.
-        // The second pair field will be false if the consumer is gone.
-        template<typename WaitPolicy, typename InputIt, details::enable_if_wait_policy_t<WaitPolicy> = 0>
-        std::pair<size_t, bool> push(WaitPolicy&& policy, InputIt first, InputIt last) const
-        {
-            return push_n(std::forward<WaitPolicy>(policy), first, std::distance(first, last));
-        }
-
-        template<typename InputIt>
-        std::pair<size_t, bool> push_n(InputIt first, size_t count) const
-        {
-            return push_n(block_forever, first, count);
-        }
-
-        // push_n writes count items from first into the queue.
-        // The amount of successfully written items is returned as the first pair field.
-        // The second pair field will be false if the consumer is gone.
-        template<typename WaitPolicy, typename InputIt, details::enable_if_wait_policy_t<WaitPolicy> = 0>
-        std::pair<size_t, bool> push_n(WaitPolicy&&, InputIt first, size_t count) const
-        {
-            details::validate_size(count);
-
-            const auto data = _arc->data();
-            auto remaining = static_cast<size_type>(count);
-            auto blocking = true;
-            auto ok = true;
-
-            while (remaining != 0)
-            {
-                auto acquisition = _arc->producer_acquire(remaining, blocking);
-                if (!acquisition.end)
-                {
-                    ok = acquisition.alive;
-                    break;
-                }
-
-                const auto begin = data + acquisition.begin;
-                const auto got = acquisition.end - acquisition.begin;
-                std::uninitialized_copy_n(first, got, begin);
-                first += got;
-                remaining -= got;
-
-                _arc->producer_release(acquisition);
-
-                if constexpr (!std::remove_reference_t<WaitPolicy>::_block_forever)
-                {
-                    blocking = false;
-                }
-            }
-
-            return { count - remaining, ok };
-        }
-
-    private:
-        void drop()
-        {
-            if (_arc)
-            {
-                _arc->drop_producer();
-            }
-        }
-
-        details::arc<T>* _arc = nullptr;
-    };
-
-    template<typename T>
-    struct consumer
-    {
-        explicit consumer(details::arc<T>* arc) noexcept :
-            _arc(arc) {}
-
-        consumer<T>(const consumer<T>&) = delete;
-        consumer<T>& operator=(const consumer<T>&) = delete;
-
-        consumer(consumer<T>&& other) noexcept
-        {
-            drop();
-            _arc = std::exchange(other._arc, nullptr);
-        }
-
-        consumer<T>& operator=(consumer<T>&& other) noexcept
-        {
-            drop();
-            _arc = std::exchange(other._arc, nullptr);
-        }
-
-        ~consumer()
-        {
-            drop();
-        }
-
-        // pop returns the next item in the queue, or std::nullopt if the producer is gone.
-        std::optional<T> pop() const
-        {
-            auto acquisition = _arc->consumer_acquire(1, true);
-            if (!acquisition.end)
-            {
-                return std::nullopt;
-            }
-
-            auto data = _arc->data();
-            auto begin = data + acquisition.begin;
-
-            auto item = std::move(*begin);
-            std::destroy_at(begin);
-
-            _arc->consumer_release(acquisition);
-            return item;
-        }
-
-        template<typename OutputIt>
-        std::pair<size_t, bool> pop_n(OutputIt first, size_t count) const
-        {
-            return pop_n(block_forever, first, count);
-        }
-
-        // pop_n reads up to count items into first.
-        // The amount of successfully read items is returned as the first pair field.
-        // The second pair field will be false if the consumer is gone.
-        template<typename WaitPolicy, typename OutputIt, details::enable_if_wait_policy_t<WaitPolicy> = 0>
-        std::pair<size_t, bool> pop_n(WaitPolicy&&, OutputIt first, size_t count) const
-        {
-            details::validate_size(count);
-
-            const auto data = _arc->data();
-            auto remaining = static_cast<size_type>(count);
-            auto blocking = true;
-            auto ok = true;
-
-            while (remaining != 0)
-            {
-                auto acquisition = _arc->consumer_acquire(remaining, blocking);
-                if (!acquisition.end)
-                {
-                    ok = acquisition.alive;
-                    break;
-                }
-
-                auto beg = data + acquisition.begin;
-                auto end = data + acquisition.end;
-                auto got = acquisition.end - acquisition.begin;
-                first = std::move(beg, end, first);
-                std::destroy(beg, end);
-                remaining -= got;
-
-                _arc->consumer_release(acquisition);
-
-                if constexpr (!std::remove_reference_t<WaitPolicy>::_block_forever)
-                {
-                    blocking = false;
-                }
-            }
-
-            return { count - remaining, ok };
-        }
-
-    private:
-        void drop()
-        {
-            if (_arc)
-            {
-                _arc->drop_consumer();
-            }
-        }
-
-        details::arc<T>* _arc = nullptr;
-    };
-
-    // channel returns a bounded, lock-free, single-producer, single-consumer
-    // FIFO queue ("channel") with the given maximum capacity.
-    template<typename T>
-    std::pair<producer<T>, consumer<T>> channel(uint32_t capacity)
-    {
-        if (capacity == 0)
-        {
-            throw std::invalid_argument{ "invalid capacity" };
-        }
-
-        const auto arc = new details::arc<T>(capacity);
-        return { std::piecewise_construct, std::forward_as_tuple(arc), std::forward_as_tuple(arc) };
-    }
-}

src/interactivity/onecore/BgfxEngine.cpp

@@ -145,7 +145,7 @@ BgfxEngine::BgfxEngine(PVOID SharedViewBase, LONG DisplayHeight, LONG DisplayWid
     return S_OK;
 }
 
-[[nodiscard]] HRESULT BgfxEngine::PaintBufferLine(const gsl::span<const Cluster> clusters,
+[[nodiscard]] HRESULT BgfxEngine::PaintBufferLine(const std::basic_string_view<Cluster> clusters,
                                                   const COORD coord,
                                                   const bool /*trimLeft*/,
                                                   const bool /*lineWrapped*/) noexcept